//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS Connect service.
///
///    Amazon Connect actions     Amazon Connect data types    Amazon Connect is a cloud-based contact center solution that you use to set up and manage a customer contact center and provide reliable customer engagement at any scale. Amazon Connect provides metrics and real-time reporting that enable you to optimize contact routing. You can also resolve customer issues more efficiently by getting customers in touch with the appropriate agents. There are limits to the number of Amazon Connect resources that you can create. There are also limits to the number of requests that you can make per second. For more information, see Amazon Connect Service Quotas in the Amazon Connect Administrator Guide. You can use an endpoint to connect programmatically to an Amazon Web Services service. For a list of Amazon Connect endpoints, see Amazon Connect Endpoints.
public struct Connect: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the Connect client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "Connect",
            serviceIdentifier: "connect",
            serviceProtocol: .restjson,
            apiVersion: "2017-08-08",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: ConnectErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.fips]: .init(endpoints: [
            "ca-central-1": "connect-fips.ca-central-1.amazonaws.com",
            "us-east-1": "connect-fips.us-east-1.amazonaws.com",
            "us-gov-west-1": "connect.us-gov-west-1.amazonaws.com",
            "us-west-2": "connect-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Activates an evaluation form in the specified Amazon Connect instance. After the evaluation form is activated, it is available to start new evaluations based on the form.
    @Sendable
    @inlinable
    public func activateEvaluationForm(_ input: ActivateEvaluationFormRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ActivateEvaluationFormResponse {
        try await self.client.execute(
            operation: "ActivateEvaluationForm", 
            path: "/evaluation-forms/{InstanceId}/{EvaluationFormId}/activate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Activates an evaluation form in the specified Amazon Connect instance. After the evaluation form is activated, it is available to start new evaluations based on the form.
    ///
    /// Parameters:
    ///   - evaluationFormId: The unique identifier for the evaluation form.
    ///   - evaluationFormVersion: The version of the evaluation form to activate. If the version property is not provided, the latest version of the evaluation form is activated.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func activateEvaluationForm(
        evaluationFormId: String,
        evaluationFormVersion: Int = 0,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ActivateEvaluationFormResponse {
        let input = ActivateEvaluationFormRequest(
            evaluationFormId: evaluationFormId, 
            evaluationFormVersion: evaluationFormVersion, 
            instanceId: instanceId
        )
        return try await self.activateEvaluationForm(input, logger: logger)
    }

    /// Associates the specified dataset for a Amazon Connect instance with the target account. You can associate only one dataset in a single call.
    @Sendable
    @inlinable
    public func associateAnalyticsDataSet(_ input: AssociateAnalyticsDataSetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateAnalyticsDataSetResponse {
        try await self.client.execute(
            operation: "AssociateAnalyticsDataSet", 
            path: "/analytics-data/instance/{InstanceId}/association", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates the specified dataset for a Amazon Connect instance with the target account. You can associate only one dataset in a single call.
    ///
    /// Parameters:
    ///   - dataSetId: The identifier of the dataset to associate with the target account.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - targetAccountId: The identifier of the target account.  Use to associate a dataset to a different account than the one containing the Amazon Connect instance. If not specified, by default this value is the Amazon Web Services account that has the Amazon Connect instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateAnalyticsDataSet(
        dataSetId: String,
        instanceId: String,
        targetAccountId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateAnalyticsDataSetResponse {
        let input = AssociateAnalyticsDataSetRequest(
            dataSetId: dataSetId, 
            instanceId: instanceId, 
            targetAccountId: targetAccountId
        )
        return try await self.associateAnalyticsDataSet(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Associates an approved origin to an Amazon Connect instance.
    @Sendable
    @inlinable
    public func associateApprovedOrigin(_ input: AssociateApprovedOriginRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "AssociateApprovedOrigin", 
            path: "/instance/{InstanceId}/approved-origin", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Associates an approved origin to an Amazon Connect instance.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - origin: The domain to add to your allow list.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateApprovedOrigin(
        clientToken: String? = AssociateApprovedOriginRequest.idempotencyToken(),
        instanceId: String,
        origin: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = AssociateApprovedOriginRequest(
            clientToken: clientToken, 
            instanceId: instanceId, 
            origin: origin
        )
        return try await self.associateApprovedOrigin(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Allows the specified Amazon Connect instance to access the specified Amazon Lex or Amazon Lex V2 bot.
    @Sendable
    @inlinable
    public func associateBot(_ input: AssociateBotRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "AssociateBot", 
            path: "/instance/{InstanceId}/bot", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Allows the specified Amazon Connect instance to access the specified Amazon Lex or Amazon Lex V2 bot.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - lexBot: 
    ///   - lexV2Bot: The Amazon Lex V2 bot to associate with the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateBot(
        clientToken: String? = AssociateBotRequest.idempotencyToken(),
        instanceId: String,
        lexBot: LexBot? = nil,
        lexV2Bot: LexV2Bot? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = AssociateBotRequest(
            clientToken: clientToken, 
            instanceId: instanceId, 
            lexBot: lexBot, 
            lexV2Bot: lexV2Bot
        )
        return try await self.associateBot(input, logger: logger)
    }

    /// Associates an existing vocabulary as the default. Contact Lens for Amazon Connect uses the vocabulary in post-call and real-time analysis sessions for the given language.
    @Sendable
    @inlinable
    public func associateDefaultVocabulary(_ input: AssociateDefaultVocabularyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateDefaultVocabularyResponse {
        try await self.client.execute(
            operation: "AssociateDefaultVocabulary", 
            path: "/default-vocabulary/{InstanceId}/{LanguageCode}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates an existing vocabulary as the default. Contact Lens for Amazon Connect uses the vocabulary in post-call and real-time analysis sessions for the given language.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - languageCode: The language code of the vocabulary entries. For a list of languages and their corresponding language codes, see
    ///   - vocabularyId: The identifier of the custom vocabulary. If this is empty, the default is set to none.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateDefaultVocabulary(
        instanceId: String,
        languageCode: VocabularyLanguageCode,
        vocabularyId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateDefaultVocabularyResponse {
        let input = AssociateDefaultVocabularyRequest(
            instanceId: instanceId, 
            languageCode: languageCode, 
            vocabularyId: vocabularyId
        )
        return try await self.associateDefaultVocabulary(input, logger: logger)
    }

    /// Associates a connect resource to a flow.
    @Sendable
    @inlinable
    public func associateFlow(_ input: AssociateFlowRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateFlowResponse {
        try await self.client.execute(
            operation: "AssociateFlow", 
            path: "/flow-associations/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a connect resource to a flow.
    ///
    /// Parameters:
    ///   - flowId: The identifier of the flow.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - resourceId: The identifier of the resource.   Amazon Web Services End User Messaging SMS phone number ARN when using SMS_PHONE_NUMBER    Amazon Web Services End User Messaging Social phone number ARN when using WHATSAPP_MESSAGING_PHONE_NUMBER
    ///   - resourceType: A valid resource type.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateFlow(
        flowId: String,
        instanceId: String,
        resourceId: String,
        resourceType: FlowAssociationResourceType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateFlowResponse {
        let input = AssociateFlowRequest(
            flowId: flowId, 
            instanceId: instanceId, 
            resourceId: resourceId, 
            resourceType: resourceType
        )
        return try await self.associateFlow(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Associates a storage resource type for the first time. You can only associate one type of storage configuration in a single call. This means, for example, that you can't define an instance with multiple S3 buckets for storing chat transcripts. This API does not create a resource that doesn't exist. It only associates it to the instance. Ensure that the resource being specified in the storage configuration, like an S3 bucket, exists when being used for association.
    @Sendable
    @inlinable
    public func associateInstanceStorageConfig(_ input: AssociateInstanceStorageConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateInstanceStorageConfigResponse {
        try await self.client.execute(
            operation: "AssociateInstanceStorageConfig", 
            path: "/instance/{InstanceId}/storage-config", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Associates a storage resource type for the first time. You can only associate one type of storage configuration in a single call. This means, for example, that you can't define an instance with multiple S3 buckets for storing chat transcripts. This API does not create a resource that doesn't exist. It only associates it to the instance. Ensure that the resource being specified in the storage configuration, like an S3 bucket, exists when being used for association.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - resourceType: A valid resource type. To enable streaming for real-time analysis of contacts, use the following types:   For chat contacts, use REAL_TIME_CONTACT_ANALYSIS_CHAT_SEGMENTS.   For voice contacts, use REAL_TIME_CONTACT_ANALYSIS_VOICE_SEGMENTS.     REAL_TIME_CONTACT_ANALYSIS_SEGMENTS is deprecated, but it is still supported and will apply only to VOICE channel contacts. Use REAL_TIME_CONTACT_ANALYSIS_VOICE_SEGMENTS for voice contacts moving forward. If you have previously associated a stream with REAL_TIME_CONTACT_ANALYSIS_SEGMENTS, no action is needed to update the stream to REAL_TIME_CONTACT_ANALYSIS_VOICE_SEGMENTS.
    ///   - storageConfig: A valid storage type.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateInstanceStorageConfig(
        clientToken: String? = AssociateInstanceStorageConfigRequest.idempotencyToken(),
        instanceId: String,
        resourceType: InstanceStorageResourceType,
        storageConfig: InstanceStorageConfig,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateInstanceStorageConfigResponse {
        let input = AssociateInstanceStorageConfigRequest(
            clientToken: clientToken, 
            instanceId: instanceId, 
            resourceType: resourceType, 
            storageConfig: storageConfig
        )
        return try await self.associateInstanceStorageConfig(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Allows the specified Amazon Connect instance to access the specified Lambda function.
    @Sendable
    @inlinable
    public func associateLambdaFunction(_ input: AssociateLambdaFunctionRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "AssociateLambdaFunction", 
            path: "/instance/{InstanceId}/lambda-function", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Allows the specified Amazon Connect instance to access the specified Lambda function.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - functionArn: The Amazon Resource Name (ARN) for the Lambda function being associated. Maximum number of characters allowed is 140.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateLambdaFunction(
        clientToken: String? = AssociateLambdaFunctionRequest.idempotencyToken(),
        functionArn: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = AssociateLambdaFunctionRequest(
            clientToken: clientToken, 
            functionArn: functionArn, 
            instanceId: instanceId
        )
        return try await self.associateLambdaFunction(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Allows the specified Amazon Connect instance to access the specified Amazon Lex V1 bot. This API only supports the association of Amazon Lex V1 bots.
    @Sendable
    @inlinable
    public func associateLexBot(_ input: AssociateLexBotRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "AssociateLexBot", 
            path: "/instance/{InstanceId}/lex-bot", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Allows the specified Amazon Connect instance to access the specified Amazon Lex V1 bot. This API only supports the association of Amazon Lex V1 bots.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - lexBot: The Amazon Lex bot to associate with the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateLexBot(
        clientToken: String? = AssociateLexBotRequest.idempotencyToken(),
        instanceId: String,
        lexBot: LexBot,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = AssociateLexBotRequest(
            clientToken: clientToken, 
            instanceId: instanceId, 
            lexBot: lexBot
        )
        return try await self.associateLexBot(input, logger: logger)
    }

    /// Associates a flow with a phone number claimed to your Amazon Connect instance.  If the number is claimed to a traffic distribution group, and you are calling this API using an instance in the Amazon Web Services Region where the traffic distribution group was created, you can use either a full phone number ARN or UUID value for the PhoneNumberId URI request parameter. However, if the number is claimed to a traffic distribution group and you are calling this API using an instance in the alternate Amazon Web Services Region associated with the traffic distribution group, you must provide a full phone number ARN. If a UUID is provided in this scenario, you will receive a ResourceNotFoundException.
    @Sendable
    @inlinable
    public func associatePhoneNumberContactFlow(_ input: AssociatePhoneNumberContactFlowRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "AssociatePhoneNumberContactFlow", 
            path: "/phone-number/{PhoneNumberId}/contact-flow", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a flow with a phone number claimed to your Amazon Connect instance.  If the number is claimed to a traffic distribution group, and you are calling this API using an instance in the Amazon Web Services Region where the traffic distribution group was created, you can use either a full phone number ARN or UUID value for the PhoneNumberId URI request parameter. However, if the number is claimed to a traffic distribution group and you are calling this API using an instance in the alternate Amazon Web Services Region associated with the traffic distribution group, you must provide a full phone number ARN. If a UUID is provided in this scenario, you will receive a ResourceNotFoundException.
    ///
    /// Parameters:
    ///   - contactFlowId: The identifier of the flow.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - phoneNumberId: A unique identifier for the phone number.
    ///   - logger: Logger use during operation
    @inlinable
    public func associatePhoneNumberContactFlow(
        contactFlowId: String,
        instanceId: String,
        phoneNumberId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = AssociatePhoneNumberContactFlowRequest(
            contactFlowId: contactFlowId, 
            instanceId: instanceId, 
            phoneNumberId: phoneNumberId
        )
        return try await self.associatePhoneNumberContactFlow(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Associates a set of quick connects with a queue.
    @Sendable
    @inlinable
    public func associateQueueQuickConnects(_ input: AssociateQueueQuickConnectsRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "AssociateQueueQuickConnects", 
            path: "/queues/{InstanceId}/{QueueId}/associate-quick-connects", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Associates a set of quick connects with a queue.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - queueId: The identifier for the queue.
    ///   - quickConnectIds: The quick connects to associate with this queue.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateQueueQuickConnects(
        instanceId: String,
        queueId: String,
        quickConnectIds: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = AssociateQueueQuickConnectsRequest(
            instanceId: instanceId, 
            queueId: queueId, 
            quickConnectIds: quickConnectIds
        )
        return try await self.associateQueueQuickConnects(input, logger: logger)
    }

    /// Associates a set of queues with a routing profile.
    @Sendable
    @inlinable
    public func associateRoutingProfileQueues(_ input: AssociateRoutingProfileQueuesRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "AssociateRoutingProfileQueues", 
            path: "/routing-profiles/{InstanceId}/{RoutingProfileId}/associate-queues", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a set of queues with a routing profile.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - queueConfigs: The queues to associate with this routing profile.
    ///   - routingProfileId: The identifier of the routing profile.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateRoutingProfileQueues(
        instanceId: String,
        queueConfigs: [RoutingProfileQueueConfig],
        routingProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = AssociateRoutingProfileQueuesRequest(
            instanceId: instanceId, 
            queueConfigs: queueConfigs, 
            routingProfileId: routingProfileId
        )
        return try await self.associateRoutingProfileQueues(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Associates a security key to the instance.
    @Sendable
    @inlinable
    public func associateSecurityKey(_ input: AssociateSecurityKeyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateSecurityKeyResponse {
        try await self.client.execute(
            operation: "AssociateSecurityKey", 
            path: "/instance/{InstanceId}/security-key", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Associates a security key to the instance.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - key: A valid security key in PEM format as a String.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateSecurityKey(
        clientToken: String? = AssociateSecurityKeyRequest.idempotencyToken(),
        instanceId: String,
        key: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateSecurityKeyResponse {
        let input = AssociateSecurityKeyRequest(
            clientToken: clientToken, 
            instanceId: instanceId, 
            key: key
        )
        return try await self.associateSecurityKey(input, logger: logger)
    }

    /// Associates an agent with a traffic distribution group. This API can be called only in the Region where the traffic distribution group is created.
    @Sendable
    @inlinable
    public func associateTrafficDistributionGroupUser(_ input: AssociateTrafficDistributionGroupUserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateTrafficDistributionGroupUserResponse {
        try await self.client.execute(
            operation: "AssociateTrafficDistributionGroupUser", 
            path: "/traffic-distribution-group/{TrafficDistributionGroupId}/user", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates an agent with a traffic distribution group. This API can be called only in the Region where the traffic distribution group is created.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - trafficDistributionGroupId: The identifier of the traffic distribution group.
    ///   - userId: The identifier of the user account. This can be the ID or the ARN of the user.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateTrafficDistributionGroupUser(
        instanceId: String,
        trafficDistributionGroupId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateTrafficDistributionGroupUserResponse {
        let input = AssociateTrafficDistributionGroupUserRequest(
            instanceId: instanceId, 
            trafficDistributionGroupId: trafficDistributionGroupId, 
            userId: userId
        )
        return try await self.associateTrafficDistributionGroupUser(input, logger: logger)
    }

    /// Associates a set of proficiencies with a user.
    @Sendable
    @inlinable
    public func associateUserProficiencies(_ input: AssociateUserProficienciesRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "AssociateUserProficiencies", 
            path: "/users/{InstanceId}/{UserId}/associate-proficiencies", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a set of proficiencies with a user.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN of the instance).
    ///   - userId: The identifier of the user account.
    ///   - userProficiencies: The proficiencies to associate with the user.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateUserProficiencies(
        instanceId: String,
        userId: String,
        userProficiencies: [UserProficiency],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = AssociateUserProficienciesRequest(
            instanceId: instanceId, 
            userId: userId, 
            userProficiencies: userProficiencies
        )
        return try await self.associateUserProficiencies(input, logger: logger)
    }

    /// Associates a list of analytics datasets for a given Amazon Connect instance to a target account. You can associate multiple datasets in a single call.
    @Sendable
    @inlinable
    public func batchAssociateAnalyticsDataSet(_ input: BatchAssociateAnalyticsDataSetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchAssociateAnalyticsDataSetResponse {
        try await self.client.execute(
            operation: "BatchAssociateAnalyticsDataSet", 
            path: "/analytics-data/instance/{InstanceId}/associations", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a list of analytics datasets for a given Amazon Connect instance to a target account. You can associate multiple datasets in a single call.
    ///
    /// Parameters:
    ///   - dataSetIds: An array of dataset identifiers to associate.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - targetAccountId: The identifier of the target account.  Use to associate a dataset to a different account than the one containing the Amazon Connect instance. If not specified, by default this value is the Amazon Web Services account that has the Amazon Connect instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchAssociateAnalyticsDataSet(
        dataSetIds: [String],
        instanceId: String,
        targetAccountId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchAssociateAnalyticsDataSetResponse {
        let input = BatchAssociateAnalyticsDataSetRequest(
            dataSetIds: dataSetIds, 
            instanceId: instanceId, 
            targetAccountId: targetAccountId
        )
        return try await self.batchAssociateAnalyticsDataSet(input, logger: logger)
    }

    /// Removes a list of analytics datasets associated with a given Amazon Connect instance. You can disassociate multiple datasets in a single call.
    @Sendable
    @inlinable
    public func batchDisassociateAnalyticsDataSet(_ input: BatchDisassociateAnalyticsDataSetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchDisassociateAnalyticsDataSetResponse {
        try await self.client.execute(
            operation: "BatchDisassociateAnalyticsDataSet", 
            path: "/analytics-data/instance/{InstanceId}/associations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes a list of analytics datasets associated with a given Amazon Connect instance. You can disassociate multiple datasets in a single call.
    ///
    /// Parameters:
    ///   - dataSetIds: An array of associated dataset identifiers to remove.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - targetAccountId: The identifier of the target account.  Use to disassociate a dataset from a different account than the one containing the Amazon Connect instance. If not specified, by default this value is the Amazon Web Services account that has the Amazon Connect instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchDisassociateAnalyticsDataSet(
        dataSetIds: [String],
        instanceId: String,
        targetAccountId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchDisassociateAnalyticsDataSetResponse {
        let input = BatchDisassociateAnalyticsDataSetRequest(
            dataSetIds: dataSetIds, 
            instanceId: instanceId, 
            targetAccountId: targetAccountId
        )
        return try await self.batchDisassociateAnalyticsDataSet(input, logger: logger)
    }

    /// Allows you to retrieve metadata about multiple attached files on an associated resource. Each attached file provided in the input list must be associated with the input AssociatedResourceArn.
    @Sendable
    @inlinable
    public func batchGetAttachedFileMetadata(_ input: BatchGetAttachedFileMetadataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchGetAttachedFileMetadataResponse {
        try await self.client.execute(
            operation: "BatchGetAttachedFileMetadata", 
            path: "/attached-files/{InstanceId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Allows you to retrieve metadata about multiple attached files on an associated resource. Each attached file provided in the input list must be associated with the input AssociatedResourceArn.
    ///
    /// Parameters:
    ///   - associatedResourceArn: The resource to which the attached file is (being) uploaded to. The supported resources are Cases and Email.  This value must be a valid ARN.
    ///   - fileIds: The unique identifiers of the attached file resource.
    ///   - instanceId: The unique identifier of the Connect instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchGetAttachedFileMetadata(
        associatedResourceArn: String,
        fileIds: [String],
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchGetAttachedFileMetadataResponse {
        let input = BatchGetAttachedFileMetadataRequest(
            associatedResourceArn: associatedResourceArn, 
            fileIds: fileIds, 
            instanceId: instanceId
        )
        return try await self.batchGetAttachedFileMetadata(input, logger: logger)
    }

    /// Retrieve the flow associations for the given resources.
    @Sendable
    @inlinable
    public func batchGetFlowAssociation(_ input: BatchGetFlowAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchGetFlowAssociationResponse {
        try await self.client.execute(
            operation: "BatchGetFlowAssociation", 
            path: "/flow-associations-batch/{InstanceId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieve the flow associations for the given resources.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - resourceIds: A list of resource identifiers to retrieve flow associations.   Amazon Web Services End User Messaging SMS phone number ARN when using SMS_PHONE_NUMBER    Amazon Web Services End User Messaging Social phone number ARN when using WHATSAPP_MESSAGING_PHONE_NUMBER
    ///   - resourceType: The type of resource association.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchGetFlowAssociation(
        instanceId: String,
        resourceIds: [String],
        resourceType: ListFlowAssociationResourceType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchGetFlowAssociationResponse {
        let input = BatchGetFlowAssociationRequest(
            instanceId: instanceId, 
            resourceIds: resourceIds, 
            resourceType: resourceType
        )
        return try await self.batchGetFlowAssociation(input, logger: logger)
    }

    ///  Only the Amazon Connect outbound campaigns service principal is allowed to assume a role in your account and call this API.  Allows you to create a batch of contacts in Amazon Connect. The outbound campaigns capability ingests dial requests via the PutDialRequestBatch API. It then uses BatchPutContact to create contacts corresponding to those dial requests. If agents are available, the dial requests are dialed out, which results in a voice call. The resulting voice call uses the same contactId that was created by BatchPutContact.
    @Sendable
    @inlinable
    public func batchPutContact(_ input: BatchPutContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchPutContactResponse {
        try await self.client.execute(
            operation: "BatchPutContact", 
            path: "/contact/batch/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Only the Amazon Connect outbound campaigns service principal is allowed to assume a role in your account and call this API.  Allows you to create a batch of contacts in Amazon Connect. The outbound campaigns capability ingests dial requests via the PutDialRequestBatch API. It then uses BatchPutContact to create contacts corresponding to those dial requests. If agents are available, the dial requests are dialed out, which results in a voice call. The resulting voice call uses the same contactId that was created by BatchPutContact.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - contactDataRequestList: List of individual contact requests.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchPutContact(
        clientToken: String? = BatchPutContactRequest.idempotencyToken(),
        contactDataRequestList: [ContactDataRequest],
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchPutContactResponse {
        let input = BatchPutContactRequest(
            clientToken: clientToken, 
            contactDataRequestList: contactDataRequestList, 
            instanceId: instanceId
        )
        return try await self.batchPutContact(input, logger: logger)
    }

    /// Claims an available phone number to your Amazon Connect instance or traffic distribution group. You can call this API only in the same Amazon Web Services Region where the Amazon Connect instance or traffic distribution group was created. For more information about how to use this operation, see Claim a phone number in your country and Claim phone numbers to traffic distribution groups in the Amazon Connect Administrator Guide.   You can call the SearchAvailablePhoneNumbers API for available phone numbers that you can claim. Call the DescribePhoneNumber API to verify the status of a previous ClaimPhoneNumber operation.  If you plan to claim and release numbers frequently, contact us for a service quota exception. Otherwise, it is possible you will be blocked from claiming and releasing any more numbers until up to 180 days past the oldest number released has expired. By default you can claim and release up to 200% of your maximum number of active phone numbers. If you claim and release phone numbers using the UI or API during a rolling 180 day cycle that exceeds 200% of your phone number service level quota, you will be blocked from claiming any more numbers until 180 days past the oldest number released has expired.  For example, if you already have 99 claimed numbers and a service level quota of 99 phone numbers, and in any 180 day period you release 99, claim 99, and then release 99, you will have exceeded the 200% limit. At that point you are blocked from claiming any more numbers until you open an Amazon Web Services support ticket.
    @Sendable
    @inlinable
    public func claimPhoneNumber(_ input: ClaimPhoneNumberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ClaimPhoneNumberResponse {
        try await self.client.execute(
            operation: "ClaimPhoneNumber", 
            path: "/phone-number/claim", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Claims an available phone number to your Amazon Connect instance or traffic distribution group. You can call this API only in the same Amazon Web Services Region where the Amazon Connect instance or traffic distribution group was created. For more information about how to use this operation, see Claim a phone number in your country and Claim phone numbers to traffic distribution groups in the Amazon Connect Administrator Guide.   You can call the SearchAvailablePhoneNumbers API for available phone numbers that you can claim. Call the DescribePhoneNumber API to verify the status of a previous ClaimPhoneNumber operation.  If you plan to claim and release numbers frequently, contact us for a service quota exception. Otherwise, it is possible you will be blocked from claiming and releasing any more numbers until up to 180 days past the oldest number released has expired. By default you can claim and release up to 200% of your maximum number of active phone numbers. If you claim and release phone numbers using the UI or API during a rolling 180 day cycle that exceeds 200% of your phone number service level quota, you will be blocked from claiming any more numbers until 180 days past the oldest number released has expired.  For example, if you already have 99 claimed numbers and a service level quota of 99 phone numbers, and in any 180 day period you release 99, claim 99, and then release 99, you will have exceeded the 200% limit. At that point you are blocked from claiming any more numbers until you open an Amazon Web Services support ticket.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs. Pattern: ^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$
    ///   - instanceId: The identifier of the Amazon Connect instance that phone numbers are claimed to. You can find the instance ID in the Amazon Resource Name (ARN) of the instance. You must enter InstanceId or TargetArn.
    ///   - phoneNumber: The phone number you want to claim. Phone numbers are formatted [+] [country code] [subscriber number including area code].
    ///   - phoneNumberDescription: The description of the phone number.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - targetArn: The Amazon Resource Name (ARN) for Amazon Connect instances or traffic distribution groups that phone number inbound traffic is routed through. You must enter InstanceId or TargetArn.
    ///   - logger: Logger use during operation
    @inlinable
    public func claimPhoneNumber(
        clientToken: String? = ClaimPhoneNumberRequest.idempotencyToken(),
        instanceId: String? = nil,
        phoneNumber: String,
        phoneNumberDescription: String? = nil,
        tags: [String: String]? = nil,
        targetArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ClaimPhoneNumberResponse {
        let input = ClaimPhoneNumberRequest(
            clientToken: clientToken, 
            instanceId: instanceId, 
            phoneNumber: phoneNumber, 
            phoneNumberDescription: phoneNumberDescription, 
            tags: tags, 
            targetArn: targetArn
        )
        return try await self.claimPhoneNumber(input, logger: logger)
    }

    /// Allows you to confirm that the attached file has been uploaded using the pre-signed URL provided in the StartAttachedFileUpload API.
    @Sendable
    @inlinable
    public func completeAttachedFileUpload(_ input: CompleteAttachedFileUploadRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CompleteAttachedFileUploadResponse {
        try await self.client.execute(
            operation: "CompleteAttachedFileUpload", 
            path: "/attached-files/{InstanceId}/{FileId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Allows you to confirm that the attached file has been uploaded using the pre-signed URL provided in the StartAttachedFileUpload API.
    ///
    /// Parameters:
    ///   - associatedResourceArn: The resource to which the attached file is (being) uploaded to. The supported resources are Cases and Email.  This value must be a valid ARN.
    ///   - fileId: The unique identifier of the attached file resource.
    ///   - instanceId: The unique identifier of the Amazon Connect instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func completeAttachedFileUpload(
        associatedResourceArn: String,
        fileId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CompleteAttachedFileUploadResponse {
        let input = CompleteAttachedFileUploadRequest(
            associatedResourceArn: associatedResourceArn, 
            fileId: fileId, 
            instanceId: instanceId
        )
        return try await self.completeAttachedFileUpload(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Creates an agent status for the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func createAgentStatus(_ input: CreateAgentStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAgentStatusResponse {
        try await self.client.execute(
            operation: "CreateAgentStatus", 
            path: "/agent-status/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Creates an agent status for the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - description: The description of the status.
    ///   - displayOrder: The display order of the status.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the status.
    ///   - state: The state of the status.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAgentStatus(
        description: String? = nil,
        displayOrder: Int? = nil,
        instanceId: String,
        name: String,
        state: AgentStatusState,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAgentStatusResponse {
        let input = CreateAgentStatusRequest(
            description: description, 
            displayOrder: displayOrder, 
            instanceId: instanceId, 
            name: name, 
            state: state, 
            tags: tags
        )
        return try await self.createAgentStatus(input, logger: logger)
    }

    ///  Only the VOICE, EMAIL, and TASK channels are supported.    For VOICE: The supported initiation method is TRANSFER. The contacts created with this initiation method have a subtype connect:ExternalAudio.    For EMAIL: The supported initiation methods are OUTBOUND, AGENT_REPLY, and FLOW.    For TASK: The supported initiation method is API. Contacts created with this API have a sub-type of connect:ExternalTask.    Creates a new VOICE, EMAIL, or TASK contact.  After a contact is created, you can move it to the desired state by using the InitiateAs parameter. While you can use API to create task contacts that are in the COMPLETED state, you must contact Amazon Web Services Support before using it for bulk import use cases. Bulk import causes your requests to be throttled or fail if your CreateContact limits aren't high enough.
    @Sendable
    @inlinable
    public func createContact(_ input: CreateContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateContactResponse {
        try await self.client.execute(
            operation: "CreateContact", 
            path: "/contact/create-contact", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Only the VOICE, EMAIL, and TASK channels are supported.    For VOICE: The supported initiation method is TRANSFER. The contacts created with this initiation method have a subtype connect:ExternalAudio.    For EMAIL: The supported initiation methods are OUTBOUND, AGENT_REPLY, and FLOW.    For TASK: The supported initiation method is API. Contacts created with this API have a sub-type of connect:ExternalTask.    Creates a new VOICE, EMAIL, or TASK contact.  After a contact is created, you can move it to the desired state by using the InitiateAs parameter. While you can use API to create task contacts that are in the COMPLETED state, you must contact Amazon Web Services Support before using it for bulk import use cases. Bulk import causes your requests to be throttled or fail if your CreateContact limits aren't high enough.
    ///
    /// Parameters:
    ///   - attributes: A custom key-value pair using an attribute map. The attributes are standard Amazon Connect attributes, and can be accessed in flows just like any other contact attributes. There can be up to 32,768 UTF-8 bytes across all key-value pairs per contact. Attribute keys can include only alphanumeric, dash, and underscore characters.
    ///   - channel: The channel for the contact.  The CHAT channel is not supported. The following information is incorrect. We're working to correct it.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - description: A description of the contact.
    ///   - expiryDurationInMinutes: Number of minutes the contact will be active for before expiring
    ///   - initiateAs: Initial state of the contact when it's created. Only TASK channel contacts can be initiated with COMPLETED state.
    ///   - initiationMethod: Indicates how the contact was initiated.   CreateContact only supports the following initiation methods. Valid values by channel are:    For VOICE: TRANSFER and the subtype connect:ExternalAudio    For EMAIL: OUTBOUND | AGENT_REPLY | FLOW    For TASK: API    The other channels listed below are incorrect. We're working to correct this information.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of a the contact.
    ///   - previousContactId: The ID of the previous contact when creating a transfer contact. This value can be provided only for external audio contacts. For more information, see Integrate Amazon Connect Contact Lens with external voice systems in the Amazon Connect Administrator Guide.
    ///   - references: A formatted URL that is shown to an agent in the Contact Control Panel (CCP). Tasks can have the following reference types at the time of creation: URL | NUMBER | STRING | DATE | EMAIL | ATTACHMENT.
    ///   - relatedContactId: The identifier of the contact in this instance of Amazon Connect.
    ///   - segmentAttributes: A set of system defined key-value pairs stored on individual contact segments (unique contact ID) using an attribute map. The attributes are standard Amazon Connect attributes. They can be accessed in flows. Attribute keys can include only alphanumeric, -, and _. This field can be used to set Segment Contact Expiry as a duration in minutes.  To set contact expiry, a ValueMap must be specified containing the integer number of minutes the contact will be active for before expiring, with SegmentAttributes like {  "connect:ContactExpiry": {"ValueMap" : { "ExpiryDuration": { "ValueInteger": 135}}}}.
    ///   - userInfo: User details for the contact  UserInfo is required when creating an EMAIL contact with OUTBOUND and AGENT_REPLY contact initiation methods.
    ///   - logger: Logger use during operation
    @inlinable
    public func createContact(
        attributes: [String: String]? = nil,
        channel: Channel,
        clientToken: String? = CreateContactRequest.idempotencyToken(),
        description: String? = nil,
        expiryDurationInMinutes: Int? = nil,
        initiateAs: InitiateAs? = nil,
        initiationMethod: ContactInitiationMethod,
        instanceId: String,
        name: String? = nil,
        previousContactId: String? = nil,
        references: [String: Reference]? = nil,
        relatedContactId: String? = nil,
        segmentAttributes: [String: SegmentAttributeValue]? = nil,
        userInfo: UserInfo? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateContactResponse {
        let input = CreateContactRequest(
            attributes: attributes, 
            channel: channel, 
            clientToken: clientToken, 
            description: description, 
            expiryDurationInMinutes: expiryDurationInMinutes, 
            initiateAs: initiateAs, 
            initiationMethod: initiationMethod, 
            instanceId: instanceId, 
            name: name, 
            previousContactId: previousContactId, 
            references: references, 
            relatedContactId: relatedContactId, 
            segmentAttributes: segmentAttributes, 
            userInfo: userInfo
        )
        return try await self.createContact(input, logger: logger)
    }

    /// Creates a flow for the specified Amazon Connect instance. You can also create and update flows using the Amazon Connect Flow language.
    @Sendable
    @inlinable
    public func createContactFlow(_ input: CreateContactFlowRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateContactFlowResponse {
        try await self.client.execute(
            operation: "CreateContactFlow", 
            path: "/contact-flows/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a flow for the specified Amazon Connect instance. You can also create and update flows using the Amazon Connect Flow language.
    ///
    /// Parameters:
    ///   - content: The JSON string that represents the content of the flow. For an example, see Example flow in Amazon Connect Flow language.  Length Constraints: Minimum length of 1. Maximum length of 256000.
    ///   - description: The description of the flow.
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - name: The name of the flow.
    ///   - status: Indicates the flow status as either SAVED or PUBLISHED. The PUBLISHED status will initiate validation on the content. the SAVED status does not initiate validation of the content. SAVED | PUBLISHED.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - type: The type of the flow. For descriptions of the available types, see Choose a flow type in the Amazon Connect Administrator Guide.
    ///   - logger: Logger use during operation
    @inlinable
    public func createContactFlow(
        content: String,
        description: String? = nil,
        instanceId: String,
        name: String,
        status: ContactFlowStatus? = nil,
        tags: [String: String]? = nil,
        type: ContactFlowType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateContactFlowResponse {
        let input = CreateContactFlowRequest(
            content: content, 
            description: description, 
            instanceId: instanceId, 
            name: name, 
            status: status, 
            tags: tags, 
            type: type
        )
        return try await self.createContactFlow(input, logger: logger)
    }

    /// Creates a flow module for the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func createContactFlowModule(_ input: CreateContactFlowModuleRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateContactFlowModuleResponse {
        try await self.client.execute(
            operation: "CreateContactFlowModule", 
            path: "/contact-flow-modules/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a flow module for the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - content: The JSON string that represents the content of the flow. For an example, see Example flow in Amazon Connect Flow language.
    ///   - description: The description of the flow module.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the flow module.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - logger: Logger use during operation
    @inlinable
    public func createContactFlowModule(
        clientToken: String? = CreateContactFlowModuleRequest.idempotencyToken(),
        content: String,
        description: String? = nil,
        instanceId: String,
        name: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateContactFlowModuleResponse {
        let input = CreateContactFlowModuleRequest(
            clientToken: clientToken, 
            content: content, 
            description: description, 
            instanceId: instanceId, 
            name: name, 
            tags: tags
        )
        return try await self.createContactFlowModule(input, logger: logger)
    }

    /// Publishes a new version of the flow provided. Versions are immutable and monotonically increasing. If the FlowContentSha256 provided is different from the FlowContentSha256 of the $LATEST published flow content, then an error is returned. This API only supports creating versions for flows of type Campaign.
    @Sendable
    @inlinable
    public func createContactFlowVersion(_ input: CreateContactFlowVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateContactFlowVersionResponse {
        try await self.client.execute(
            operation: "CreateContactFlowVersion", 
            path: "/contact-flows/{InstanceId}/{ContactFlowId}/version", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Publishes a new version of the flow provided. Versions are immutable and monotonically increasing. If the FlowContentSha256 provided is different from the FlowContentSha256 of the $LATEST published flow content, then an error is returned. This API only supports creating versions for flows of type Campaign.
    ///
    /// Parameters:
    ///   - contactFlowId: The identifier of the flow.
    ///   - contactFlowVersion: The identifier of the flow version.
    ///   - description: The description of the flow version.
    ///   - flowContentSha256: Indicates the checksum value of the flow content.
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - lastModifiedRegion: The Amazon Web Services Region where this resource was last modified.
    ///   - lastModifiedTime: The Amazon Web Services Region where this resource was last modified.
    ///   - logger: Logger use during operation
    @inlinable
    public func createContactFlowVersion(
        contactFlowId: String,
        contactFlowVersion: Int64? = nil,
        description: String? = nil,
        flowContentSha256: String? = nil,
        instanceId: String,
        lastModifiedRegion: String? = nil,
        lastModifiedTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateContactFlowVersionResponse {
        let input = CreateContactFlowVersionRequest(
            contactFlowId: contactFlowId, 
            contactFlowVersion: contactFlowVersion, 
            description: description, 
            flowContentSha256: flowContentSha256, 
            instanceId: instanceId, 
            lastModifiedRegion: lastModifiedRegion, 
            lastModifiedTime: lastModifiedTime
        )
        return try await self.createContactFlowVersion(input, logger: logger)
    }

    /// Create new email address in the specified Amazon Connect instance. For more information about email addresses, see Create email addresses in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func createEmailAddress(_ input: CreateEmailAddressRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateEmailAddressResponse {
        try await self.client.execute(
            operation: "CreateEmailAddress", 
            path: "/email-addresses/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Create new email address in the specified Amazon Connect instance. For more information about email addresses, see Create email addresses in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - description: The description of the email address.
    ///   - displayName: The display name of email address
    ///   - emailAddress: The email address, including the domain.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - logger: Logger use during operation
    @inlinable
    public func createEmailAddress(
        clientToken: String? = nil,
        description: String? = nil,
        displayName: String? = nil,
        emailAddress: String,
        instanceId: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateEmailAddressResponse {
        let input = CreateEmailAddressRequest(
            clientToken: clientToken, 
            description: description, 
            displayName: displayName, 
            emailAddress: emailAddress, 
            instanceId: instanceId, 
            tags: tags
        )
        return try await self.createEmailAddress(input, logger: logger)
    }

    /// Creates an evaluation form in the specified Amazon Connect instance. The form can be used to define questions related to agent performance, and create sections to organize such questions. Question and section identifiers cannot be duplicated within the same evaluation form.
    @Sendable
    @inlinable
    public func createEvaluationForm(_ input: CreateEvaluationFormRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateEvaluationFormResponse {
        try await self.client.execute(
            operation: "CreateEvaluationForm", 
            path: "/evaluation-forms/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an evaluation form in the specified Amazon Connect instance. The form can be used to define questions related to agent performance, and create sections to organize such questions. Question and section identifiers cannot be duplicated within the same evaluation form.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - description: The description of the evaluation form.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - items: Items that are part of the evaluation form.  The total number of sections and questions must not exceed 100 each.  Questions must be contained in a section.
    ///   - scoringStrategy: A scoring strategy of the evaluation form.
    ///   - title: A title of the evaluation form.
    ///   - logger: Logger use during operation
    @inlinable
    public func createEvaluationForm(
        clientToken: String? = CreateEvaluationFormRequest.idempotencyToken(),
        description: String? = nil,
        instanceId: String,
        items: [EvaluationFormItem],
        scoringStrategy: EvaluationFormScoringStrategy? = nil,
        title: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateEvaluationFormResponse {
        let input = CreateEvaluationFormRequest(
            clientToken: clientToken, 
            description: description, 
            instanceId: instanceId, 
            items: items, 
            scoringStrategy: scoringStrategy, 
            title: title
        )
        return try await self.createEvaluationForm(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Creates hours of operation.
    @Sendable
    @inlinable
    public func createHoursOfOperation(_ input: CreateHoursOfOperationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateHoursOfOperationResponse {
        try await self.client.execute(
            operation: "CreateHoursOfOperation", 
            path: "/hours-of-operations/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Creates hours of operation.
    ///
    /// Parameters:
    ///   - config: Configuration information for the hours of operation: day, start time, and end time.
    ///   - description: The description of the hours of operation.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the hours of operation.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - timeZone: The time zone of the hours of operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func createHoursOfOperation(
        config: [HoursOfOperationConfig],
        description: String? = nil,
        instanceId: String,
        name: String,
        tags: [String: String]? = nil,
        timeZone: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateHoursOfOperationResponse {
        let input = CreateHoursOfOperationRequest(
            config: config, 
            description: description, 
            instanceId: instanceId, 
            name: name, 
            tags: tags, 
            timeZone: timeZone
        )
        return try await self.createHoursOfOperation(input, logger: logger)
    }

    /// Creates an hours of operation override in an Amazon Connect hours of operation resource
    @Sendable
    @inlinable
    public func createHoursOfOperationOverride(_ input: CreateHoursOfOperationOverrideRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateHoursOfOperationOverrideResponse {
        try await self.client.execute(
            operation: "CreateHoursOfOperationOverride", 
            path: "/hours-of-operations/{InstanceId}/{HoursOfOperationId}/overrides", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an hours of operation override in an Amazon Connect hours of operation resource
    ///
    /// Parameters:
    ///   - config: Configuration information for the hours of operation override: day, start time, and end time.
    ///   - description: The description of the hours of operation override.
    ///   - effectiveFrom: The date from when the hours of operation override would be effective.
    ///   - effectiveTill: The date until when the hours of operation override would be effective.
    ///   - hoursOfOperationId: The identifier for the hours of operation
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - name: The name of the hours of operation override.
    ///   - logger: Logger use during operation
    @inlinable
    public func createHoursOfOperationOverride(
        config: [HoursOfOperationOverrideConfig],
        description: String? = nil,
        effectiveFrom: String,
        effectiveTill: String,
        hoursOfOperationId: String,
        instanceId: String,
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateHoursOfOperationOverrideResponse {
        let input = CreateHoursOfOperationOverrideRequest(
            config: config, 
            description: description, 
            effectiveFrom: effectiveFrom, 
            effectiveTill: effectiveTill, 
            hoursOfOperationId: hoursOfOperationId, 
            instanceId: instanceId, 
            name: name
        )
        return try await self.createHoursOfOperationOverride(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Initiates an Amazon Connect instance with all the supported channels enabled. It does not attach any storage, such as Amazon Simple Storage Service (Amazon S3) or Amazon Kinesis. It also does not allow for any configurations on features, such as Contact Lens for Amazon Connect.  For more information, see Create an Amazon Connect instance in the Amazon Connect Administrator Guide. Amazon Connect enforces a limit on the total number of instances that you can create or delete in 30 days.
    /// If you exceed this limit, you will get an error message indicating there has been an excessive number of attempts at creating or deleting instances.
    /// You must wait 30 days before you can restart creating and deleting instances in your account.
    @Sendable
    @inlinable
    public func createInstance(_ input: CreateInstanceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateInstanceResponse {
        try await self.client.execute(
            operation: "CreateInstance", 
            path: "/instance", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Initiates an Amazon Connect instance with all the supported channels enabled. It does not attach any storage, such as Amazon Simple Storage Service (Amazon S3) or Amazon Kinesis. It also does not allow for any configurations on features, such as Contact Lens for Amazon Connect.  For more information, see Create an Amazon Connect instance in the Amazon Connect Administrator Guide. Amazon Connect enforces a limit on the total number of instances that you can create or delete in 30 days.
    /// If you exceed this limit, you will get an error message indicating there has been an excessive number of attempts at creating or deleting instances.
    /// You must wait 30 days before you can restart creating and deleting instances in your account.
    ///
    /// Parameters:
    ///   - clientToken: The idempotency token.
    ///   - directoryId: The identifier for the directory.
    ///   - identityManagementType: The type of identity management for your Amazon Connect users.
    ///   - inboundCallsEnabled: Your contact center handles incoming contacts.
    ///   - instanceAlias: The name for your instance.
    ///   - outboundCallsEnabled: Your contact center allows outbound calls.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "tags": {"key1":"value1", "key2":"value2"} }.
    ///   - logger: Logger use during operation
    @inlinable
    public func createInstance(
        clientToken: String? = CreateInstanceRequest.idempotencyToken(),
        directoryId: String? = nil,
        identityManagementType: DirectoryType,
        inboundCallsEnabled: Bool,
        instanceAlias: String? = nil,
        outboundCallsEnabled: Bool,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateInstanceResponse {
        let input = CreateInstanceRequest(
            clientToken: clientToken, 
            directoryId: directoryId, 
            identityManagementType: identityManagementType, 
            inboundCallsEnabled: inboundCallsEnabled, 
            instanceAlias: instanceAlias, 
            outboundCallsEnabled: outboundCallsEnabled, 
            tags: tags
        )
        return try await self.createInstance(input, logger: logger)
    }

    /// Creates an Amazon Web Services resource association with an Amazon Connect instance.
    @Sendable
    @inlinable
    public func createIntegrationAssociation(_ input: CreateIntegrationAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateIntegrationAssociationResponse {
        try await self.client.execute(
            operation: "CreateIntegrationAssociation", 
            path: "/instance/{InstanceId}/integration-associations", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Web Services resource association with an Amazon Connect instance.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - integrationArn: The Amazon Resource Name (ARN) of the integration.  When integrating with Amazon Web Services End User Messaging, the Amazon Connect and Amazon Web Services End User Messaging instances must be in the same account.
    ///   - integrationType: The type of information to be ingested.
    ///   - sourceApplicationName: The name of the external application. This field is only required for the EVENT integration type.
    ///   - sourceApplicationUrl: The URL for the external application. This field is only required for the EVENT integration type.
    ///   - sourceType: The type of the data source. This field is only required for the EVENT integration type.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - logger: Logger use during operation
    @inlinable
    public func createIntegrationAssociation(
        instanceId: String,
        integrationArn: String,
        integrationType: IntegrationType,
        sourceApplicationName: String? = nil,
        sourceApplicationUrl: String? = nil,
        sourceType: SourceType? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateIntegrationAssociationResponse {
        let input = CreateIntegrationAssociationRequest(
            instanceId: instanceId, 
            integrationArn: integrationArn, 
            integrationType: integrationType, 
            sourceApplicationName: sourceApplicationName, 
            sourceApplicationUrl: sourceApplicationUrl, 
            sourceType: sourceType, 
            tags: tags
        )
        return try await self.createIntegrationAssociation(input, logger: logger)
    }

    /// Adds a new participant into an on-going chat contact. For more information, see Customize chat flow experiences by integrating custom participants.
    @Sendable
    @inlinable
    public func createParticipant(_ input: CreateParticipantRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateParticipantResponse {
        try await self.client.execute(
            operation: "CreateParticipant", 
            path: "/contact/create-participant", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds a new participant into an on-going chat contact. For more information, see Customize chat flow experiences by integrating custom participants.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - contactId: The identifier of the contact in this instance of Amazon Connect.  Only contacts in the CHAT channel are supported.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - participantDetails: Information identifying the participant.  The only Valid value for ParticipantRole is CUSTOM_BOT.   DisplayName is Required.
    ///   - logger: Logger use during operation
    @inlinable
    public func createParticipant(
        clientToken: String? = CreateParticipantRequest.idempotencyToken(),
        contactId: String,
        instanceId: String,
        participantDetails: ParticipantDetailsToAdd,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateParticipantResponse {
        let input = CreateParticipantRequest(
            clientToken: clientToken, 
            contactId: contactId, 
            instanceId: instanceId, 
            participantDetails: participantDetails
        )
        return try await self.createParticipant(input, logger: logger)
    }

    /// Enables rehydration of chats for the lifespan of a contact. For more information about chat rehydration, see Enable persistent chat in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func createPersistentContactAssociation(_ input: CreatePersistentContactAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreatePersistentContactAssociationResponse {
        try await self.client.execute(
            operation: "CreatePersistentContactAssociation", 
            path: "/contact/persistent-contact-association/{InstanceId}/{InitialContactId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables rehydration of chats for the lifespan of a contact. For more information about chat rehydration, see Enable persistent chat in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - initialContactId: This is the contactId of the current contact that the CreatePersistentContactAssociation API is being called from.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - rehydrationType: The contactId chosen for rehydration depends on the type chosen.    ENTIRE_PAST_SESSION: Rehydrates a chat from the most recently terminated past chat contact of the specified past ended chat session. To use this type, provide the initialContactId of the past ended chat session in the sourceContactId field. In this type, Amazon Connect determines what the most recent chat contact on the past ended chat session and uses it to start a persistent chat.     FROM_SEGMENT: Rehydrates a chat from the specified past chat contact provided in the sourceContactId field.    The actual contactId used for rehydration is provided in the response of this API. To illustrate how to use rehydration type, consider the following example: A customer starts a chat session. Agent a1 accepts the chat and a conversation starts between the customer and Agent a1. This first contact creates a contact ID C1. Agent a1 then transfers the chat to Agent a2. This creates another contact ID C2. At this point Agent a2 ends the chat. The customer is forwarded to the disconnect flow for a post chat survey that creates another contact ID C3. After the chat survey, the chat session ends. Later, the customer returns and wants to resume their past chat session. At this point, the customer can have following use cases:     Use Case 1: The customer wants to continue the past chat session but they want to hide the post chat survey. For this they will use the following configuration:    Configuration    SourceContactId = "C2"   RehydrationType = "FROM_SEGMENT"      Expected behavior    This starts a persistent chat session from the specified past ended contact (C2). Transcripts of past chat sessions C2 and C1 are accessible in the current persistent chat session. Note that chat segment C3 is dropped from the persistent chat session.        Use Case 2: The customer wants to continue the past chat session and see the transcript of the entire past engagement, including the post chat survey. For this they will use the following configuration:    Configuration    SourceContactId = "C1"   RehydrationType = "ENTIRE_PAST_SESSION"      Expected behavior    This starts a persistent chat session from the most recently ended chat contact (C3). Transcripts of past chat sessions C3, C2 and C1 are accessible in the current persistent chat session.
    ///   - sourceContactId: The contactId from which a persistent chat session must be started.
    ///   - logger: Logger use during operation
    @inlinable
    public func createPersistentContactAssociation(
        clientToken: String? = nil,
        initialContactId: String,
        instanceId: String,
        rehydrationType: RehydrationType,
        sourceContactId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreatePersistentContactAssociationResponse {
        let input = CreatePersistentContactAssociationRequest(
            clientToken: clientToken, 
            initialContactId: initialContactId, 
            instanceId: instanceId, 
            rehydrationType: rehydrationType, 
            sourceContactId: sourceContactId
        )
        return try await self.createPersistentContactAssociation(input, logger: logger)
    }

    /// Creates a new predefined attribute for the specified Amazon Connect instance. Predefined attributes are attributes in an Amazon Connect instance that can be used to route contacts to an agent or pools of agents within a queue. For more information, see Create predefined attributes for routing contacts to agents.
    @Sendable
    @inlinable
    public func createPredefinedAttribute(_ input: CreatePredefinedAttributeRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "CreatePredefinedAttribute", 
            path: "/predefined-attributes/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new predefined attribute for the specified Amazon Connect instance. Predefined attributes are attributes in an Amazon Connect instance that can be used to route contacts to an agent or pools of agents within a queue. For more information, see Create predefined attributes for routing contacts to agents.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name:  The name of the predefined attribute.
    ///   - values:  The values of the predefined attribute.
    ///   - logger: Logger use during operation
    @inlinable
    public func createPredefinedAttribute(
        instanceId: String,
        name: String,
        values: PredefinedAttributeValues,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = CreatePredefinedAttributeRequest(
            instanceId: instanceId, 
            name: name, 
            values: values
        )
        return try await self.createPredefinedAttribute(input, logger: logger)
    }

    /// Creates a prompt. For more information about prompts, such as supported file types and maximum length, see Create prompts in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func createPrompt(_ input: CreatePromptRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreatePromptResponse {
        try await self.client.execute(
            operation: "CreatePrompt", 
            path: "/prompts/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a prompt. For more information about prompts, such as supported file types and maximum length, see Create prompts in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - description: The description of the prompt.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the prompt.
    ///   - s3Uri: The URI for the S3 bucket where the prompt is stored. You can provide S3 pre-signed URLs returned by the
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - logger: Logger use during operation
    @inlinable
    public func createPrompt(
        description: String? = nil,
        instanceId: String,
        name: String,
        s3Uri: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreatePromptResponse {
        let input = CreatePromptRequest(
            description: description, 
            instanceId: instanceId, 
            name: name, 
            s3Uri: s3Uri, 
            tags: tags
        )
        return try await self.createPrompt(input, logger: logger)
    }

    /// Creates registration for a device token and a chat contact to receive real-time push notifications. For more information about push notifications, see Set up push notifications in Amazon Connect for mobile chat in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func createPushNotificationRegistration(_ input: CreatePushNotificationRegistrationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreatePushNotificationRegistrationResponse {
        try await self.client.execute(
            operation: "CreatePushNotificationRegistration", 
            path: "/push-notification/{InstanceId}/registrations", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates registration for a device token and a chat contact to receive real-time push notifications. For more information about push notifications, see Set up push notifications in Amazon Connect for mobile chat in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - contactConfiguration: The contact configuration for push notification registration.
    ///   - deviceToken: The push notification token issued by the Apple or Google gateways.
    ///   - deviceType: The device type to use when sending the message.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - pinpointAppArn: The Amazon Resource Name (ARN) of the Pinpoint application.
    ///   - logger: Logger use during operation
    @inlinable
    public func createPushNotificationRegistration(
        clientToken: String? = CreatePushNotificationRegistrationRequest.idempotencyToken(),
        contactConfiguration: ContactConfiguration,
        deviceToken: String,
        deviceType: DeviceType,
        instanceId: String,
        pinpointAppArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreatePushNotificationRegistrationResponse {
        let input = CreatePushNotificationRegistrationRequest(
            clientToken: clientToken, 
            contactConfiguration: contactConfiguration, 
            deviceToken: deviceToken, 
            deviceType: deviceType, 
            instanceId: instanceId, 
            pinpointAppArn: pinpointAppArn
        )
        return try await self.createPushNotificationRegistration(input, logger: logger)
    }

    /// Creates a new queue for the specified Amazon Connect instance.    If the phone number is claimed to a traffic distribution group that was created in the same Region as the Amazon Connect instance where you are calling this API, then you can use a full phone number ARN or a UUID for OutboundCallerIdNumberId. However, if the phone number is claimed to a traffic distribution group that is in one Region, and you are calling this API from an instance in another Amazon Web Services Region that is associated with the traffic distribution group, you must provide a full phone number ARN. If a UUID is provided in this scenario, you will receive a ResourceNotFoundException.   Only use the phone number ARN format that doesn't contain instance in the path, for example, arn:aws:connect:us-east-1:1234567890:phone-number/uuid. This is the same ARN format that is returned when you call the ListPhoneNumbersV2 API.   If you plan to use IAM policies to allow/deny access to this API for phone number resources claimed to a traffic distribution group, see Allow or Deny queue API actions for phone numbers in a replica Region.
    @Sendable
    @inlinable
    public func createQueue(_ input: CreateQueueRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateQueueResponse {
        try await self.client.execute(
            operation: "CreateQueue", 
            path: "/queues/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new queue for the specified Amazon Connect instance.    If the phone number is claimed to a traffic distribution group that was created in the same Region as the Amazon Connect instance where you are calling this API, then you can use a full phone number ARN or a UUID for OutboundCallerIdNumberId. However, if the phone number is claimed to a traffic distribution group that is in one Region, and you are calling this API from an instance in another Amazon Web Services Region that is associated with the traffic distribution group, you must provide a full phone number ARN. If a UUID is provided in this scenario, you will receive a ResourceNotFoundException.   Only use the phone number ARN format that doesn't contain instance in the path, for example, arn:aws:connect:us-east-1:1234567890:phone-number/uuid. This is the same ARN format that is returned when you call the ListPhoneNumbersV2 API.   If you plan to use IAM policies to allow/deny access to this API for phone number resources claimed to a traffic distribution group, see Allow or Deny queue API actions for phone numbers in a replica Region.
    ///
    /// Parameters:
    ///   - description: The description of the queue.
    ///   - hoursOfOperationId: The identifier for the hours of operation.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxContacts: The maximum number of contacts that can be in the queue before it is considered full.
    ///   - name: The name of the queue.
    ///   - outboundCallerConfig: The outbound caller ID name, number, and outbound whisper flow.
    ///   - outboundEmailConfig: The outbound email address ID for a specified queue.
    ///   - quickConnectIds: The quick connects available to agents who are working the queue.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - logger: Logger use during operation
    @inlinable
    public func createQueue(
        description: String? = nil,
        hoursOfOperationId: String,
        instanceId: String,
        maxContacts: Int? = nil,
        name: String,
        outboundCallerConfig: OutboundCallerConfig? = nil,
        outboundEmailConfig: OutboundEmailConfig? = nil,
        quickConnectIds: [String]? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateQueueResponse {
        let input = CreateQueueRequest(
            description: description, 
            hoursOfOperationId: hoursOfOperationId, 
            instanceId: instanceId, 
            maxContacts: maxContacts, 
            name: name, 
            outboundCallerConfig: outboundCallerConfig, 
            outboundEmailConfig: outboundEmailConfig, 
            quickConnectIds: quickConnectIds, 
            tags: tags
        )
        return try await self.createQueue(input, logger: logger)
    }

    /// Creates a quick connect for the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func createQuickConnect(_ input: CreateQuickConnectRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateQuickConnectResponse {
        try await self.client.execute(
            operation: "CreateQuickConnect", 
            path: "/quick-connects/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a quick connect for the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - description: The description of the quick connect.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: A unique name of the quick connect.
    ///   - quickConnectConfig: Configuration settings for the quick connect.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - logger: Logger use during operation
    @inlinable
    public func createQuickConnect(
        description: String? = nil,
        instanceId: String,
        name: String,
        quickConnectConfig: QuickConnectConfig,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateQuickConnectResponse {
        let input = CreateQuickConnectRequest(
            description: description, 
            instanceId: instanceId, 
            name: name, 
            quickConnectConfig: quickConnectConfig, 
            tags: tags
        )
        return try await self.createQuickConnect(input, logger: logger)
    }

    /// Creates a new routing profile.
    @Sendable
    @inlinable
    public func createRoutingProfile(_ input: CreateRoutingProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateRoutingProfileResponse {
        try await self.client.execute(
            operation: "CreateRoutingProfile", 
            path: "/routing-profiles/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new routing profile.
    ///
    /// Parameters:
    ///   - agentAvailabilityTimer: Whether agents with this routing profile will have their routing order calculated based on longest idle time or time since their last inbound contact.
    ///   - defaultOutboundQueueId: The default outbound queue for the routing profile.
    ///   - description: Description of the routing profile. Must not be more than 250 characters.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - mediaConcurrencies: The channels that agents can handle in the Contact Control Panel (CCP) for this routing profile.
    ///   - name: The name of the routing profile. Must not be more than 127 characters.
    ///   - queueConfigs: The inbound queues associated with the routing profile. If no queue is added, the agent can make only outbound calls. The limit of 10 array members applies to the maximum number of RoutingProfileQueueConfig objects that can be passed during a CreateRoutingProfile API request. It is different from the quota of 50 queues per routing profile per instance that is listed in Amazon Connect service quotas.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - logger: Logger use during operation
    @inlinable
    public func createRoutingProfile(
        agentAvailabilityTimer: AgentAvailabilityTimer? = nil,
        defaultOutboundQueueId: String,
        description: String,
        instanceId: String,
        mediaConcurrencies: [MediaConcurrency],
        name: String,
        queueConfigs: [RoutingProfileQueueConfig]? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateRoutingProfileResponse {
        let input = CreateRoutingProfileRequest(
            agentAvailabilityTimer: agentAvailabilityTimer, 
            defaultOutboundQueueId: defaultOutboundQueueId, 
            description: description, 
            instanceId: instanceId, 
            mediaConcurrencies: mediaConcurrencies, 
            name: name, 
            queueConfigs: queueConfigs, 
            tags: tags
        )
        return try await self.createRoutingProfile(input, logger: logger)
    }

    /// Creates a rule for the specified Amazon Connect instance. Use the Rules Function language to code conditions for the rule.
    @Sendable
    @inlinable
    public func createRule(_ input: CreateRuleRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateRuleResponse {
        try await self.client.execute(
            operation: "CreateRule", 
            path: "/rules/{InstanceId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a rule for the specified Amazon Connect instance. Use the Rules Function language to code conditions for the rule.
    ///
    /// Parameters:
    ///   - actions: A list of actions to be run when the rule is triggered.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - function: The conditions of the rule.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: A unique name for the rule.
    ///   - publishStatus: The publish status of the rule.
    ///   - triggerEventSource: The event source to trigger the rule.
    ///   - logger: Logger use during operation
    @inlinable
    public func createRule(
        actions: [RuleAction],
        clientToken: String? = CreateRuleRequest.idempotencyToken(),
        function: String,
        instanceId: String,
        name: String,
        publishStatus: RulePublishStatus,
        triggerEventSource: RuleTriggerEventSource,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateRuleResponse {
        let input = CreateRuleRequest(
            actions: actions, 
            clientToken: clientToken, 
            function: function, 
            instanceId: instanceId, 
            name: name, 
            publishStatus: publishStatus, 
            triggerEventSource: triggerEventSource
        )
        return try await self.createRule(input, logger: logger)
    }

    /// Creates a security profile. For information about security profiles, see Security Profiles in the Amazon Connect Administrator Guide. For a mapping of the API name and user interface name of the security profile permissions, see List of security profile permissions.
    @Sendable
    @inlinable
    public func createSecurityProfile(_ input: CreateSecurityProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSecurityProfileResponse {
        try await self.client.execute(
            operation: "CreateSecurityProfile", 
            path: "/security-profiles/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a security profile. For information about security profiles, see Security Profiles in the Amazon Connect Administrator Guide. For a mapping of the API name and user interface name of the security profile permissions, see List of security profile permissions.
    ///
    /// Parameters:
    ///   - allowedAccessControlHierarchyGroupId: The identifier of the hierarchy group that a security profile uses to restrict access to resources in Amazon Connect.
    ///   - allowedAccessControlTags: The list of tags that a security profile uses to restrict access to resources in Amazon Connect.
    ///   - applications: A list of third-party applications that the security profile will give access to.
    ///   - description: The description of the security profile.
    ///   - hierarchyRestrictedResources: The list of resources that a security profile applies hierarchy restrictions to in Amazon Connect. Following are acceptable ResourceNames: User.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - permissions: Permissions assigned to the security profile. For a list of valid permissions, see List of security profile permissions.
    ///   - securityProfileName: The name of the security profile.
    ///   - tagRestrictedResources: The list of resources that a security profile applies tag restrictions to in Amazon Connect. For a list of Amazon Connect resources that you can tag, see Add tags to resources in Amazon Connect in the Amazon Connect Administrator Guide.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSecurityProfile(
        allowedAccessControlHierarchyGroupId: String? = nil,
        allowedAccessControlTags: [String: String]? = nil,
        applications: [Application]? = nil,
        description: String? = nil,
        hierarchyRestrictedResources: [String]? = nil,
        instanceId: String,
        permissions: [String]? = nil,
        securityProfileName: String,
        tagRestrictedResources: [String]? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSecurityProfileResponse {
        let input = CreateSecurityProfileRequest(
            allowedAccessControlHierarchyGroupId: allowedAccessControlHierarchyGroupId, 
            allowedAccessControlTags: allowedAccessControlTags, 
            applications: applications, 
            description: description, 
            hierarchyRestrictedResources: hierarchyRestrictedResources, 
            instanceId: instanceId, 
            permissions: permissions, 
            securityProfileName: securityProfileName, 
            tagRestrictedResources: tagRestrictedResources, 
            tags: tags
        )
        return try await self.createSecurityProfile(input, logger: logger)
    }

    /// Creates a new task template in the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func createTaskTemplate(_ input: CreateTaskTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateTaskTemplateResponse {
        try await self.client.execute(
            operation: "CreateTaskTemplate", 
            path: "/instance/{InstanceId}/task/template", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new task template in the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - constraints: Constraints that are applicable to the fields listed.
    ///   - contactFlowId: The identifier of the flow that runs by default when a task is created by referencing this template.
    ///   - defaults: The default values for fields when a task is created by referencing this template.
    ///   - description: The description of the task template.
    ///   - fields: Fields that are part of the template.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the task template.
    ///   - selfAssignFlowId: The ContactFlowId for the flow that will be run if this template is used to create a self-assigned task.
    ///   - status: Marks a template as ACTIVE or INACTIVE for a task to refer to it.
    ///   - logger: Logger use during operation
    @inlinable
    public func createTaskTemplate(
        clientToken: String? = CreateTaskTemplateRequest.idempotencyToken(),
        constraints: TaskTemplateConstraints? = nil,
        contactFlowId: String? = nil,
        defaults: TaskTemplateDefaults? = nil,
        description: String? = nil,
        fields: [TaskTemplateField],
        instanceId: String,
        name: String,
        selfAssignFlowId: String? = nil,
        status: TaskTemplateStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateTaskTemplateResponse {
        let input = CreateTaskTemplateRequest(
            clientToken: clientToken, 
            constraints: constraints, 
            contactFlowId: contactFlowId, 
            defaults: defaults, 
            description: description, 
            fields: fields, 
            instanceId: instanceId, 
            name: name, 
            selfAssignFlowId: selfAssignFlowId, 
            status: status
        )
        return try await self.createTaskTemplate(input, logger: logger)
    }

    /// Creates a traffic distribution group given an Amazon Connect instance that has been replicated.  The SignInConfig distribution is available only on a
    /// default TrafficDistributionGroup (see the IsDefault parameter in the
    /// TrafficDistributionGroup data type). If you call UpdateTrafficDistribution with a modified SignInConfig and a non-default TrafficDistributionGroup, an InvalidRequestException is returned.  For more information about creating traffic distribution groups, see Set up traffic distribution groups in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func createTrafficDistributionGroup(_ input: CreateTrafficDistributionGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateTrafficDistributionGroupResponse {
        try await self.client.execute(
            operation: "CreateTrafficDistributionGroup", 
            path: "/traffic-distribution-group", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a traffic distribution group given an Amazon Connect instance that has been replicated.  The SignInConfig distribution is available only on a
    /// default TrafficDistributionGroup (see the IsDefault parameter in the
    /// TrafficDistributionGroup data type). If you call UpdateTrafficDistribution with a modified SignInConfig and a non-default TrafficDistributionGroup, an InvalidRequestException is returned.  For more information about creating traffic distribution groups, see Set up traffic distribution groups in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - description: A description for the traffic distribution group.
    ///   - instanceId: The identifier of the Amazon Connect instance that has been replicated. You can find the instanceId in the ARN of the instance.
    ///   - name: The name for the traffic distribution group.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - logger: Logger use during operation
    @inlinable
    public func createTrafficDistributionGroup(
        clientToken: String? = CreateTrafficDistributionGroupRequest.idempotencyToken(),
        description: String? = nil,
        instanceId: String,
        name: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateTrafficDistributionGroupResponse {
        let input = CreateTrafficDistributionGroupRequest(
            clientToken: clientToken, 
            description: description, 
            instanceId: instanceId, 
            name: name, 
            tags: tags
        )
        return try await self.createTrafficDistributionGroup(input, logger: logger)
    }

    /// Creates a use case for an integration association.
    @Sendable
    @inlinable
    public func createUseCase(_ input: CreateUseCaseRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateUseCaseResponse {
        try await self.client.execute(
            operation: "CreateUseCase", 
            path: "/instance/{InstanceId}/integration-associations/{IntegrationAssociationId}/use-cases", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a use case for an integration association.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - integrationAssociationId: The identifier for the integration association.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - useCaseType: The type of use case to associate to the integration association. Each integration association can have only one of each use case type.
    ///   - logger: Logger use during operation
    @inlinable
    public func createUseCase(
        instanceId: String,
        integrationAssociationId: String,
        tags: [String: String]? = nil,
        useCaseType: UseCaseType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateUseCaseResponse {
        let input = CreateUseCaseRequest(
            instanceId: instanceId, 
            integrationAssociationId: integrationAssociationId, 
            tags: tags, 
            useCaseType: useCaseType
        )
        return try await self.createUseCase(input, logger: logger)
    }

    /// Creates a user account for the specified Amazon Connect instance.  Certain UserIdentityInfo parameters are required in some situations. For example, Email is required if you are using SAML for identity management. FirstName and LastName are required if you are using Amazon Connect or SAML for identity management.  For information about how to create users using the Amazon Connect admin website, see Add Users in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func createUser(_ input: CreateUserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateUserResponse {
        try await self.client.execute(
            operation: "CreateUser", 
            path: "/users/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a user account for the specified Amazon Connect instance.  Certain UserIdentityInfo parameters are required in some situations. For example, Email is required if you are using SAML for identity management. FirstName and LastName are required if you are using Amazon Connect or SAML for identity management.  For information about how to create users using the Amazon Connect admin website, see Add Users in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - directoryUserId: The identifier of the user account in the directory used for identity management. If Amazon Connect cannot access the directory, you can specify this identifier to authenticate users. If you include the identifier, we assume that Amazon Connect cannot access the directory. Otherwise, the identity information is used to authenticate users from your directory. This parameter is required if you are using an existing directory for identity management in Amazon Connect when Amazon Connect cannot access your directory to authenticate users. If you are using SAML for identity management and include this parameter, an error is returned.
    ///   - hierarchyGroupId: The identifier of the hierarchy group for the user.
    ///   - identityInfo: The information about the identity of the user.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - password: The password for the user account. A password is required if you are using Amazon Connect for identity management. Otherwise, it is an error to include a password.
    ///   - phoneConfig: The phone settings for the user.
    ///   - routingProfileId: The identifier of the routing profile for the user.
    ///   - securityProfileIds: The identifier of the security profile for the user.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - username: The user name for the account. For instances not using SAML for identity management, the user name can include up to 20 characters. If you are using SAML for identity management, the user name can include up to 64 characters from [a-zA-Z0-9_-.\@]+. Username can include @ only if used in an email format. For example:   Correct: testuser   Correct: testuser@example.com   Incorrect: testuser@example
    ///   - logger: Logger use during operation
    @inlinable
    public func createUser(
        directoryUserId: String? = nil,
        hierarchyGroupId: String? = nil,
        identityInfo: UserIdentityInfo? = nil,
        instanceId: String,
        password: String? = nil,
        phoneConfig: UserPhoneConfig,
        routingProfileId: String,
        securityProfileIds: [String],
        tags: [String: String]? = nil,
        username: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateUserResponse {
        let input = CreateUserRequest(
            directoryUserId: directoryUserId, 
            hierarchyGroupId: hierarchyGroupId, 
            identityInfo: identityInfo, 
            instanceId: instanceId, 
            password: password, 
            phoneConfig: phoneConfig, 
            routingProfileId: routingProfileId, 
            securityProfileIds: securityProfileIds, 
            tags: tags, 
            username: username
        )
        return try await self.createUser(input, logger: logger)
    }

    /// Creates a new user hierarchy group.
    @Sendable
    @inlinable
    public func createUserHierarchyGroup(_ input: CreateUserHierarchyGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateUserHierarchyGroupResponse {
        try await self.client.execute(
            operation: "CreateUserHierarchyGroup", 
            path: "/user-hierarchy-groups/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new user hierarchy group.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the user hierarchy group. Must not be more than 100 characters.
    ///   - parentGroupId: The identifier for the parent hierarchy group. The user hierarchy is created at level one if the parent group ID is null.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - logger: Logger use during operation
    @inlinable
    public func createUserHierarchyGroup(
        instanceId: String,
        name: String,
        parentGroupId: String? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateUserHierarchyGroupResponse {
        let input = CreateUserHierarchyGroupRequest(
            instanceId: instanceId, 
            name: name, 
            parentGroupId: parentGroupId, 
            tags: tags
        )
        return try await self.createUserHierarchyGroup(input, logger: logger)
    }

    /// Creates a new view with the possible status of SAVED or PUBLISHED. The views will have a unique name for each connect instance. It performs basic content validation if the status is SAVED or full content validation if the status is set to PUBLISHED. An error is returned if validation fails. It associates either the $SAVED qualifier or both of the $SAVED and $LATEST qualifiers with the provided view content based on the status. The view is idempotent if ClientToken is provided.
    @Sendable
    @inlinable
    public func createView(_ input: CreateViewRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateViewResponse {
        try await self.client.execute(
            operation: "CreateView", 
            path: "/views/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new view with the possible status of SAVED or PUBLISHED. The views will have a unique name for each connect instance. It performs basic content validation if the status is SAVED or full content validation if the status is set to PUBLISHED. An error is returned if validation fails. It associates either the $SAVED qualifier or both of the $SAVED and $LATEST qualifiers with the provided view content based on the status. The view is idempotent if ClientToken is provided.
    ///
    /// Parameters:
    ///   - clientToken: A unique Id for each create view request to avoid duplicate view creation. For example, the view is idempotent ClientToken is provided.
    ///   - content: View content containing all content necessary to render a view except for runtime input data. The total uncompressed content has a maximum file size of 400kB.
    ///   - description: The description of the view.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - name: The name of the view.
    ///   - status: Indicates the view status as either SAVED or PUBLISHED. The PUBLISHED status will initiate validation on the content.
    ///   - tags: The tags associated with the view resource (not specific to view version).These tags can be used to organize, track, or control access for this resource. For example, { "tags": {"key1":"value1", "key2":"value2"} }.
    ///   - logger: Logger use during operation
    @inlinable
    public func createView(
        clientToken: String? = nil,
        content: ViewInputContent,
        description: String? = nil,
        instanceId: String,
        name: String,
        status: ViewStatus,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateViewResponse {
        let input = CreateViewRequest(
            clientToken: clientToken, 
            content: content, 
            description: description, 
            instanceId: instanceId, 
            name: name, 
            status: status, 
            tags: tags
        )
        return try await self.createView(input, logger: logger)
    }

    /// Publishes a new version of the view identifier. Versions are immutable and monotonically increasing. It returns the highest version if there is no change in content compared to that version. An error is displayed if the supplied ViewContentSha256 is different from the ViewContentSha256 of the $LATEST alias.
    @Sendable
    @inlinable
    public func createViewVersion(_ input: CreateViewVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateViewVersionResponse {
        try await self.client.execute(
            operation: "CreateViewVersion", 
            path: "/views/{InstanceId}/{ViewId}/versions", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Publishes a new version of the view identifier. Versions are immutable and monotonically increasing. It returns the highest version if there is no change in content compared to that version. An error is displayed if the supplied ViewContentSha256 is different from the ViewContentSha256 of the $LATEST alias.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - versionDescription: The description for the version being published.
    ///   - viewContentSha256: Indicates the checksum value of the latest published view content.
    ///   - viewId: The identifier of the view. Both ViewArn and ViewId can be used.
    ///   - logger: Logger use during operation
    @inlinable
    public func createViewVersion(
        instanceId: String,
        versionDescription: String? = nil,
        viewContentSha256: String? = nil,
        viewId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateViewVersionResponse {
        let input = CreateViewVersionRequest(
            instanceId: instanceId, 
            versionDescription: versionDescription, 
            viewContentSha256: viewContentSha256, 
            viewId: viewId
        )
        return try await self.createViewVersion(input, logger: logger)
    }

    /// Creates a custom vocabulary associated with your Amazon Connect instance. You can set a custom vocabulary to be your default vocabulary for a given language. Contact Lens for Amazon Connect uses the default vocabulary in post-call and real-time contact analysis sessions for that language.
    @Sendable
    @inlinable
    public func createVocabulary(_ input: CreateVocabularyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateVocabularyResponse {
        try await self.client.execute(
            operation: "CreateVocabulary", 
            path: "/vocabulary/{InstanceId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a custom vocabulary associated with your Amazon Connect instance. You can set a custom vocabulary to be your default vocabulary for a given language. Contact Lens for Amazon Connect uses the default vocabulary in post-call and real-time contact analysis sessions for that language.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs. If a create request is received more than once with same client token, subsequent requests return the previous response without creating a vocabulary again.
    ///   - content: The content of the custom vocabulary in plain-text format with a table of values. Each row in the table represents a word or a phrase, described with Phrase, IPA, SoundsLike, and DisplayAs fields. Separate the fields with TAB characters. The size limit is 50KB. For more information, see Create a custom vocabulary using a table.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - languageCode: The language code of the vocabulary entries. For a list of languages and their corresponding language codes, see
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - vocabularyName: A unique name of the custom vocabulary.
    ///   - logger: Logger use during operation
    @inlinable
    public func createVocabulary(
        clientToken: String? = CreateVocabularyRequest.idempotencyToken(),
        content: String,
        instanceId: String,
        languageCode: VocabularyLanguageCode,
        tags: [String: String]? = nil,
        vocabularyName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateVocabularyResponse {
        let input = CreateVocabularyRequest(
            clientToken: clientToken, 
            content: content, 
            instanceId: instanceId, 
            languageCode: languageCode, 
            tags: tags, 
            vocabularyName: vocabularyName
        )
        return try await self.createVocabulary(input, logger: logger)
    }

    /// Deactivates an evaluation form in the specified Amazon Connect instance. After a form is deactivated, it is no longer available for users to start new evaluations based on the form.
    @Sendable
    @inlinable
    public func deactivateEvaluationForm(_ input: DeactivateEvaluationFormRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeactivateEvaluationFormResponse {
        try await self.client.execute(
            operation: "DeactivateEvaluationForm", 
            path: "/evaluation-forms/{InstanceId}/{EvaluationFormId}/deactivate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deactivates an evaluation form in the specified Amazon Connect instance. After a form is deactivated, it is no longer available for users to start new evaluations based on the form.
    ///
    /// Parameters:
    ///   - evaluationFormId: The unique identifier for the evaluation form.
    ///   - evaluationFormVersion: A version of the evaluation form. If the version property is not provided, the latest version of the evaluation form is deactivated.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func deactivateEvaluationForm(
        evaluationFormId: String,
        evaluationFormVersion: Int = 0,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeactivateEvaluationFormResponse {
        let input = DeactivateEvaluationFormRequest(
            evaluationFormId: evaluationFormId, 
            evaluationFormVersion: evaluationFormVersion, 
            instanceId: instanceId
        )
        return try await self.deactivateEvaluationForm(input, logger: logger)
    }

    /// Deletes an attached file along with the underlying S3 Object.  The attached file is permanently deleted if S3 bucket versioning is not enabled.
    @Sendable
    @inlinable
    public func deleteAttachedFile(_ input: DeleteAttachedFileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAttachedFileResponse {
        try await self.client.execute(
            operation: "DeleteAttachedFile", 
            path: "/attached-files/{InstanceId}/{FileId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an attached file along with the underlying S3 Object.  The attached file is permanently deleted if S3 bucket versioning is not enabled.
    ///
    /// Parameters:
    ///   - associatedResourceArn: The resource to which the attached file is (being) uploaded to. Cases are the only current supported resource.  This value must be a valid ARN.
    ///   - fileId: The unique identifier of the attached file resource.
    ///   - instanceId: The unique identifier of the Connect instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAttachedFile(
        associatedResourceArn: String,
        fileId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAttachedFileResponse {
        let input = DeleteAttachedFileRequest(
            associatedResourceArn: associatedResourceArn, 
            fileId: fileId, 
            instanceId: instanceId
        )
        return try await self.deleteAttachedFile(input, logger: logger)
    }

    /// Deletes a contact evaluation in the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func deleteContactEvaluation(_ input: DeleteContactEvaluationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteContactEvaluation", 
            path: "/contact-evaluations/{InstanceId}/{EvaluationId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a contact evaluation in the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - evaluationId: A unique identifier for the contact evaluation.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteContactEvaluation(
        evaluationId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteContactEvaluationRequest(
            evaluationId: evaluationId, 
            instanceId: instanceId
        )
        return try await self.deleteContactEvaluation(input, logger: logger)
    }

    /// Deletes a flow for the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func deleteContactFlow(_ input: DeleteContactFlowRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteContactFlowResponse {
        try await self.client.execute(
            operation: "DeleteContactFlow", 
            path: "/contact-flows/{InstanceId}/{ContactFlowId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a flow for the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - contactFlowId: The identifier of the flow.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteContactFlow(
        contactFlowId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteContactFlowResponse {
        let input = DeleteContactFlowRequest(
            contactFlowId: contactFlowId, 
            instanceId: instanceId
        )
        return try await self.deleteContactFlow(input, logger: logger)
    }

    /// Deletes the specified flow module.
    @Sendable
    @inlinable
    public func deleteContactFlowModule(_ input: DeleteContactFlowModuleRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteContactFlowModuleResponse {
        try await self.client.execute(
            operation: "DeleteContactFlowModule", 
            path: "/contact-flow-modules/{InstanceId}/{ContactFlowModuleId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified flow module.
    ///
    /// Parameters:
    ///   - contactFlowModuleId: The identifier of the flow module.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteContactFlowModule(
        contactFlowModuleId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteContactFlowModuleResponse {
        let input = DeleteContactFlowModuleRequest(
            contactFlowModuleId: contactFlowModuleId, 
            instanceId: instanceId
        )
        return try await self.deleteContactFlowModule(input, logger: logger)
    }

    /// Deletes the particular version specified in flow version identifier.
    @Sendable
    @inlinable
    public func deleteContactFlowVersion(_ input: DeleteContactFlowVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteContactFlowVersionResponse {
        try await self.client.execute(
            operation: "DeleteContactFlowVersion", 
            path: "/contact-flows/{InstanceId}/{ContactFlowId}/version/{ContactFlowVersion}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the particular version specified in flow version identifier.
    ///
    /// Parameters:
    ///   - contactFlowId: The identifier of the flow.
    ///   - contactFlowVersion: The identifier of the flow version.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteContactFlowVersion(
        contactFlowId: String,
        contactFlowVersion: Int64,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteContactFlowVersionResponse {
        let input = DeleteContactFlowVersionRequest(
            contactFlowId: contactFlowId, 
            contactFlowVersion: contactFlowVersion, 
            instanceId: instanceId
        )
        return try await self.deleteContactFlowVersion(input, logger: logger)
    }

    /// Deletes email address from the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func deleteEmailAddress(_ input: DeleteEmailAddressRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteEmailAddressResponse {
        try await self.client.execute(
            operation: "DeleteEmailAddress", 
            path: "/email-addresses/{InstanceId}/{EmailAddressId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes email address from the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - emailAddressId: The identifier of the email address.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteEmailAddress(
        emailAddressId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteEmailAddressResponse {
        let input = DeleteEmailAddressRequest(
            emailAddressId: emailAddressId, 
            instanceId: instanceId
        )
        return try await self.deleteEmailAddress(input, logger: logger)
    }

    /// Deletes an evaluation form in the specified Amazon Connect instance.    If the version property is provided, only the specified version of the evaluation form is deleted.   If no version is provided, then the full form (all versions) is deleted.
    @Sendable
    @inlinable
    public func deleteEvaluationForm(_ input: DeleteEvaluationFormRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteEvaluationForm", 
            path: "/evaluation-forms/{InstanceId}/{EvaluationFormId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an evaluation form in the specified Amazon Connect instance.    If the version property is provided, only the specified version of the evaluation form is deleted.   If no version is provided, then the full form (all versions) is deleted.
    ///
    /// Parameters:
    ///   - evaluationFormId: The unique identifier for the evaluation form.
    ///   - evaluationFormVersion: The unique identifier for the evaluation form.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteEvaluationForm(
        evaluationFormId: String,
        evaluationFormVersion: Int? = nil,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteEvaluationFormRequest(
            evaluationFormId: evaluationFormId, 
            evaluationFormVersion: evaluationFormVersion, 
            instanceId: instanceId
        )
        return try await self.deleteEvaluationForm(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Deletes an hours of operation.
    @Sendable
    @inlinable
    public func deleteHoursOfOperation(_ input: DeleteHoursOfOperationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteHoursOfOperation", 
            path: "/hours-of-operations/{InstanceId}/{HoursOfOperationId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Deletes an hours of operation.
    ///
    /// Parameters:
    ///   - hoursOfOperationId: The identifier for the hours of operation.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteHoursOfOperation(
        hoursOfOperationId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteHoursOfOperationRequest(
            hoursOfOperationId: hoursOfOperationId, 
            instanceId: instanceId
        )
        return try await self.deleteHoursOfOperation(input, logger: logger)
    }

    /// Deletes an hours of operation override in an Amazon Connect hours of operation resource
    @Sendable
    @inlinable
    public func deleteHoursOfOperationOverride(_ input: DeleteHoursOfOperationOverrideRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteHoursOfOperationOverride", 
            path: "/hours-of-operations/{InstanceId}/{HoursOfOperationId}/overrides/{HoursOfOperationOverrideId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an hours of operation override in an Amazon Connect hours of operation resource
    ///
    /// Parameters:
    ///   - hoursOfOperationId: The identifier for the hours of operation.
    ///   - hoursOfOperationOverrideId: The identifier for the hours of operation override.
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteHoursOfOperationOverride(
        hoursOfOperationId: String,
        hoursOfOperationOverrideId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteHoursOfOperationOverrideRequest(
            hoursOfOperationId: hoursOfOperationId, 
            hoursOfOperationOverrideId: hoursOfOperationOverrideId, 
            instanceId: instanceId
        )
        return try await self.deleteHoursOfOperationOverride(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Deletes the Amazon Connect instance. For more information, see Delete your Amazon Connect instance in the Amazon Connect Administrator Guide. Amazon Connect enforces a limit on the total number of instances that you can create or delete in 30 days.
    /// If you exceed this limit, you will get an error message indicating there has been an excessive number of attempts at creating or deleting instances.
    /// You must wait 30 days before you can restart creating and deleting instances in your account.
    @Sendable
    @inlinable
    public func deleteInstance(_ input: DeleteInstanceRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteInstance", 
            path: "/instance/{InstanceId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Deletes the Amazon Connect instance. For more information, see Delete your Amazon Connect instance in the Amazon Connect Administrator Guide. Amazon Connect enforces a limit on the total number of instances that you can create or delete in 30 days.
    /// If you exceed this limit, you will get an error message indicating there has been an excessive number of attempts at creating or deleting instances.
    /// You must wait 30 days before you can restart creating and deleting instances in your account.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteInstance(
        clientToken: String? = DeleteInstanceRequest.idempotencyToken(),
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteInstanceRequest(
            clientToken: clientToken, 
            instanceId: instanceId
        )
        return try await self.deleteInstance(input, logger: logger)
    }

    /// Deletes an Amazon Web Services resource association from an Amazon Connect instance. The association must not have any use cases associated with it.
    @Sendable
    @inlinable
    public func deleteIntegrationAssociation(_ input: DeleteIntegrationAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteIntegrationAssociation", 
            path: "/instance/{InstanceId}/integration-associations/{IntegrationAssociationId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Amazon Web Services resource association from an Amazon Connect instance. The association must not have any use cases associated with it.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - integrationAssociationId: The identifier for the integration association.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteIntegrationAssociation(
        instanceId: String,
        integrationAssociationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteIntegrationAssociationRequest(
            instanceId: instanceId, 
            integrationAssociationId: integrationAssociationId
        )
        return try await self.deleteIntegrationAssociation(input, logger: logger)
    }

    /// Deletes a predefined attribute from the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func deletePredefinedAttribute(_ input: DeletePredefinedAttributeRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeletePredefinedAttribute", 
            path: "/predefined-attributes/{InstanceId}/{Name}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a predefined attribute from the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - instanceId:  The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name:  The name of the predefined attribute.
    ///   - logger: Logger use during operation
    @inlinable
    public func deletePredefinedAttribute(
        instanceId: String,
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeletePredefinedAttributeRequest(
            instanceId: instanceId, 
            name: name
        )
        return try await self.deletePredefinedAttribute(input, logger: logger)
    }

    /// Deletes a prompt.
    @Sendable
    @inlinable
    public func deletePrompt(_ input: DeletePromptRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeletePrompt", 
            path: "/prompts/{InstanceId}/{PromptId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a prompt.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - promptId: A unique identifier for the prompt.
    ///   - logger: Logger use during operation
    @inlinable
    public func deletePrompt(
        instanceId: String,
        promptId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeletePromptRequest(
            instanceId: instanceId, 
            promptId: promptId
        )
        return try await self.deletePrompt(input, logger: logger)
    }

    /// Deletes registration for a device token and a chat contact.
    @Sendable
    @inlinable
    public func deletePushNotificationRegistration(_ input: DeletePushNotificationRegistrationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeletePushNotificationRegistrationResponse {
        try await self.client.execute(
            operation: "DeletePushNotificationRegistration", 
            path: "/push-notification/{InstanceId}/registrations/{RegistrationId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes registration for a device token and a chat contact.
    ///
    /// Parameters:
    ///   - contactId: The identifier of the contact within the Amazon Connect instance.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - registrationId: The identifier for the registration.
    ///   - logger: Logger use during operation
    @inlinable
    public func deletePushNotificationRegistration(
        contactId: String,
        instanceId: String,
        registrationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeletePushNotificationRegistrationResponse {
        let input = DeletePushNotificationRegistrationRequest(
            contactId: contactId, 
            instanceId: instanceId, 
            registrationId: registrationId
        )
        return try await self.deletePushNotificationRegistration(input, logger: logger)
    }

    /// Deletes a queue.
    @Sendable
    @inlinable
    public func deleteQueue(_ input: DeleteQueueRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteQueue", 
            path: "/queues/{InstanceId}/{QueueId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a queue.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - queueId: The identifier for the queue.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteQueue(
        instanceId: String,
        queueId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteQueueRequest(
            instanceId: instanceId, 
            queueId: queueId
        )
        return try await self.deleteQueue(input, logger: logger)
    }

    /// Deletes a quick connect.   After calling DeleteUser, it's important to call DeleteQuickConnect to delete any records related to the deleted users. This will help you:   Avoid dangling resources that impact your service quotas.   Remove deleted users so they don't appear to agents as transfer options.   Avoid the disruption of other Amazon Connect processes, such as instance replication and syncing if you're using Amazon Connect Global Resiliency.
    @Sendable
    @inlinable
    public func deleteQuickConnect(_ input: DeleteQuickConnectRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteQuickConnect", 
            path: "/quick-connects/{InstanceId}/{QuickConnectId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a quick connect.   After calling DeleteUser, it's important to call DeleteQuickConnect to delete any records related to the deleted users. This will help you:   Avoid dangling resources that impact your service quotas.   Remove deleted users so they don't appear to agents as transfer options.   Avoid the disruption of other Amazon Connect processes, such as instance replication and syncing if you're using Amazon Connect Global Resiliency.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - quickConnectId: The identifier for the quick connect.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteQuickConnect(
        instanceId: String,
        quickConnectId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteQuickConnectRequest(
            instanceId: instanceId, 
            quickConnectId: quickConnectId
        )
        return try await self.deleteQuickConnect(input, logger: logger)
    }

    /// Deletes a routing profile.
    @Sendable
    @inlinable
    public func deleteRoutingProfile(_ input: DeleteRoutingProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteRoutingProfile", 
            path: "/routing-profiles/{InstanceId}/{RoutingProfileId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a routing profile.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - routingProfileId: The identifier of the routing profile.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteRoutingProfile(
        instanceId: String,
        routingProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteRoutingProfileRequest(
            instanceId: instanceId, 
            routingProfileId: routingProfileId
        )
        return try await self.deleteRoutingProfile(input, logger: logger)
    }

    /// Deletes a rule for the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func deleteRule(_ input: DeleteRuleRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteRule", 
            path: "/rules/{InstanceId}/{RuleId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a rule for the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - ruleId: A unique identifier for the rule.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteRule(
        instanceId: String,
        ruleId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteRuleRequest(
            instanceId: instanceId, 
            ruleId: ruleId
        )
        return try await self.deleteRule(input, logger: logger)
    }

    /// Deletes a security profile.
    @Sendable
    @inlinable
    public func deleteSecurityProfile(_ input: DeleteSecurityProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteSecurityProfile", 
            path: "/security-profiles/{InstanceId}/{SecurityProfileId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a security profile.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - securityProfileId: The identifier for the security profle.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSecurityProfile(
        instanceId: String,
        securityProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteSecurityProfileRequest(
            instanceId: instanceId, 
            securityProfileId: securityProfileId
        )
        return try await self.deleteSecurityProfile(input, logger: logger)
    }

    /// Deletes the task template.
    @Sendable
    @inlinable
    public func deleteTaskTemplate(_ input: DeleteTaskTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteTaskTemplateResponse {
        try await self.client.execute(
            operation: "DeleteTaskTemplate", 
            path: "/instance/{InstanceId}/task/template/{TaskTemplateId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the task template.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - taskTemplateId: A unique identifier for the task template.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteTaskTemplate(
        instanceId: String,
        taskTemplateId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteTaskTemplateResponse {
        let input = DeleteTaskTemplateRequest(
            instanceId: instanceId, 
            taskTemplateId: taskTemplateId
        )
        return try await self.deleteTaskTemplate(input, logger: logger)
    }

    /// Deletes a traffic distribution group. This API can be called only in the Region where the traffic distribution group is created. For more information about deleting traffic distribution groups, see Delete traffic distribution groups in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func deleteTrafficDistributionGroup(_ input: DeleteTrafficDistributionGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteTrafficDistributionGroupResponse {
        try await self.client.execute(
            operation: "DeleteTrafficDistributionGroup", 
            path: "/traffic-distribution-group/{TrafficDistributionGroupId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a traffic distribution group. This API can be called only in the Region where the traffic distribution group is created. For more information about deleting traffic distribution groups, see Delete traffic distribution groups in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - trafficDistributionGroupId: The identifier of the traffic distribution group.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteTrafficDistributionGroup(
        trafficDistributionGroupId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteTrafficDistributionGroupResponse {
        let input = DeleteTrafficDistributionGroupRequest(
            trafficDistributionGroupId: trafficDistributionGroupId
        )
        return try await self.deleteTrafficDistributionGroup(input, logger: logger)
    }

    /// Deletes a use case from an integration association.
    @Sendable
    @inlinable
    public func deleteUseCase(_ input: DeleteUseCaseRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteUseCase", 
            path: "/instance/{InstanceId}/integration-associations/{IntegrationAssociationId}/use-cases/{UseCaseId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a use case from an integration association.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - integrationAssociationId: The identifier for the integration association.
    ///   - useCaseId: The identifier for the use case.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteUseCase(
        instanceId: String,
        integrationAssociationId: String,
        useCaseId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteUseCaseRequest(
            instanceId: instanceId, 
            integrationAssociationId: integrationAssociationId, 
            useCaseId: useCaseId
        )
        return try await self.deleteUseCase(input, logger: logger)
    }

    /// Deletes a user account from the specified Amazon Connect instance. For information about what happens to a user's data when their account is deleted, see Delete Users from Your Amazon Connect Instance in the Amazon Connect Administrator Guide.  After calling DeleteUser, call DeleteQuickConnect to delete any records related to the deleted users. This will help you:   Avoid dangling resources that impact your service quotas.   Remove deleted users so they don't appear to agents as transfer options.   Avoid the disruption of other Amazon Connect processes, such as instance replication and syncing if you're using Amazon Connect Global Resiliency.
    @Sendable
    @inlinable
    public func deleteUser(_ input: DeleteUserRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteUser", 
            path: "/users/{InstanceId}/{UserId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a user account from the specified Amazon Connect instance. For information about what happens to a user's data when their account is deleted, see Delete Users from Your Amazon Connect Instance in the Amazon Connect Administrator Guide.  After calling DeleteUser, call DeleteQuickConnect to delete any records related to the deleted users. This will help you:   Avoid dangling resources that impact your service quotas.   Remove deleted users so they don't appear to agents as transfer options.   Avoid the disruption of other Amazon Connect processes, such as instance replication and syncing if you're using Amazon Connect Global Resiliency.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - userId: The identifier of the user.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteUser(
        instanceId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteUserRequest(
            instanceId: instanceId, 
            userId: userId
        )
        return try await self.deleteUser(input, logger: logger)
    }

    /// Deletes an existing user hierarchy group. It must not be associated with any agents or have any active child groups.
    @Sendable
    @inlinable
    public func deleteUserHierarchyGroup(_ input: DeleteUserHierarchyGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteUserHierarchyGroup", 
            path: "/user-hierarchy-groups/{InstanceId}/{HierarchyGroupId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an existing user hierarchy group. It must not be associated with any agents or have any active child groups.
    ///
    /// Parameters:
    ///   - hierarchyGroupId: The identifier of the hierarchy group.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteUserHierarchyGroup(
        hierarchyGroupId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteUserHierarchyGroupRequest(
            hierarchyGroupId: hierarchyGroupId, 
            instanceId: instanceId
        )
        return try await self.deleteUserHierarchyGroup(input, logger: logger)
    }

    /// Deletes the view entirely. It deletes the view and all associated qualifiers (versions and aliases).
    @Sendable
    @inlinable
    public func deleteView(_ input: DeleteViewRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteViewResponse {
        try await self.client.execute(
            operation: "DeleteView", 
            path: "/views/{InstanceId}/{ViewId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the view entirely. It deletes the view and all associated qualifiers (versions and aliases).
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - viewId: The identifier of the view. Both ViewArn and ViewId can be used.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteView(
        instanceId: String,
        viewId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteViewResponse {
        let input = DeleteViewRequest(
            instanceId: instanceId, 
            viewId: viewId
        )
        return try await self.deleteView(input, logger: logger)
    }

    /// Deletes the particular version specified in ViewVersion identifier.
    @Sendable
    @inlinable
    public func deleteViewVersion(_ input: DeleteViewVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteViewVersionResponse {
        try await self.client.execute(
            operation: "DeleteViewVersion", 
            path: "/views/{InstanceId}/{ViewId}/versions/{ViewVersion}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the particular version specified in ViewVersion identifier.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - viewId: The identifier of the view. Both ViewArn and ViewId can be used.
    ///   - viewVersion: The version number of the view.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteViewVersion(
        instanceId: String,
        viewId: String,
        viewVersion: Int,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteViewVersionResponse {
        let input = DeleteViewVersionRequest(
            instanceId: instanceId, 
            viewId: viewId, 
            viewVersion: viewVersion
        )
        return try await self.deleteViewVersion(input, logger: logger)
    }

    /// Deletes the vocabulary that has the given identifier.
    @Sendable
    @inlinable
    public func deleteVocabulary(_ input: DeleteVocabularyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteVocabularyResponse {
        try await self.client.execute(
            operation: "DeleteVocabulary", 
            path: "/vocabulary-remove/{InstanceId}/{VocabularyId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the vocabulary that has the given identifier.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - vocabularyId: The identifier of the custom vocabulary.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteVocabulary(
        instanceId: String,
        vocabularyId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteVocabularyResponse {
        let input = DeleteVocabularyRequest(
            instanceId: instanceId, 
            vocabularyId: vocabularyId
        )
        return try await self.deleteVocabulary(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Describes an agent status.
    @Sendable
    @inlinable
    public func describeAgentStatus(_ input: DescribeAgentStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeAgentStatusResponse {
        try await self.client.execute(
            operation: "DescribeAgentStatus", 
            path: "/agent-status/{InstanceId}/{AgentStatusId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Describes an agent status.
    ///
    /// Parameters:
    ///   - agentStatusId: The identifier for the agent status.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeAgentStatus(
        agentStatusId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeAgentStatusResponse {
        let input = DescribeAgentStatusRequest(
            agentStatusId: agentStatusId, 
            instanceId: instanceId
        )
        return try await self.describeAgentStatus(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. To
    /// request access to this API, contact Amazon Web ServicesSupport. Describes the target authentication profile.
    @Sendable
    @inlinable
    public func describeAuthenticationProfile(_ input: DescribeAuthenticationProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeAuthenticationProfileResponse {
        try await self.client.execute(
            operation: "DescribeAuthenticationProfile", 
            path: "/authentication-profiles/{InstanceId}/{AuthenticationProfileId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. To
    /// request access to this API, contact Amazon Web ServicesSupport. Describes the target authentication profile.
    ///
    /// Parameters:
    ///   - authenticationProfileId: A unique identifier for the authentication profile.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeAuthenticationProfile(
        authenticationProfileId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeAuthenticationProfileResponse {
        let input = DescribeAuthenticationProfileRequest(
            authenticationProfileId: authenticationProfileId, 
            instanceId: instanceId
        )
        return try await self.describeAuthenticationProfile(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Describes the specified contact.      SystemEndpoint is not populated for contacts with initiation method of MONITOR, QUEUE_TRANSFER, or CALLBACK   Contact information remains available in Amazon Connect for 24 months from the InitiationTimestamp, and then it is deleted. Only contact information that is available in Amazon Connect is returned by this API.
    @Sendable
    @inlinable
    public func describeContact(_ input: DescribeContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeContactResponse {
        try await self.client.execute(
            operation: "DescribeContact", 
            path: "/contacts/{InstanceId}/{ContactId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Describes the specified contact.      SystemEndpoint is not populated for contacts with initiation method of MONITOR, QUEUE_TRANSFER, or CALLBACK   Contact information remains available in Amazon Connect for 24 months from the InitiationTimestamp, and then it is deleted. Only contact information that is available in Amazon Connect is returned by this API.
    ///
    /// Parameters:
    ///   - contactId: The identifier of the contact.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeContact(
        contactId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeContactResponse {
        let input = DescribeContactRequest(
            contactId: contactId, 
            instanceId: instanceId
        )
        return try await self.describeContact(input, logger: logger)
    }

    /// Describes a contact evaluation in the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func describeContactEvaluation(_ input: DescribeContactEvaluationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeContactEvaluationResponse {
        try await self.client.execute(
            operation: "DescribeContactEvaluation", 
            path: "/contact-evaluations/{InstanceId}/{EvaluationId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes a contact evaluation in the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - evaluationId: A unique identifier for the contact evaluation.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeContactEvaluation(
        evaluationId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeContactEvaluationResponse {
        let input = DescribeContactEvaluationRequest(
            evaluationId: evaluationId, 
            instanceId: instanceId
        )
        return try await self.describeContactEvaluation(input, logger: logger)
    }

    /// Describes the specified flow. You can also create and update flows using the Amazon Connect Flow language. Use the $SAVED alias in the request to describe the SAVED content of a Flow. For example, arn:aws:.../contact-flow/{id}:$SAVED. After a flow is published, $SAVED needs to be supplied to view saved content that has not been published. Use arn:aws:.../contact-flow/{id}:{version} to retrieve the content of a specific flow version. In the response, Status indicates the flow status as either SAVED or PUBLISHED. The PUBLISHED status will initiate validation on the content. SAVED does not initiate validation of the content. SAVED | PUBLISHED
    @Sendable
    @inlinable
    public func describeContactFlow(_ input: DescribeContactFlowRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeContactFlowResponse {
        try await self.client.execute(
            operation: "DescribeContactFlow", 
            path: "/contact-flows/{InstanceId}/{ContactFlowId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the specified flow. You can also create and update flows using the Amazon Connect Flow language. Use the $SAVED alias in the request to describe the SAVED content of a Flow. For example, arn:aws:.../contact-flow/{id}:$SAVED. After a flow is published, $SAVED needs to be supplied to view saved content that has not been published. Use arn:aws:.../contact-flow/{id}:{version} to retrieve the content of a specific flow version. In the response, Status indicates the flow status as either SAVED or PUBLISHED. The PUBLISHED status will initiate validation on the content. SAVED does not initiate validation of the content. SAVED | PUBLISHED
    ///
    /// Parameters:
    ///   - contactFlowId: The identifier of the flow.
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeContactFlow(
        contactFlowId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeContactFlowResponse {
        let input = DescribeContactFlowRequest(
            contactFlowId: contactFlowId, 
            instanceId: instanceId
        )
        return try await self.describeContactFlow(input, logger: logger)
    }

    /// Describes the specified flow module. Use the $SAVED alias in the request to describe the SAVED content of a Flow. For example, arn:aws:.../contact-flow/{id}:$SAVED. After a flow is published, $SAVED needs to be supplied to view saved content that has not been published.
    @Sendable
    @inlinable
    public func describeContactFlowModule(_ input: DescribeContactFlowModuleRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeContactFlowModuleResponse {
        try await self.client.execute(
            operation: "DescribeContactFlowModule", 
            path: "/contact-flow-modules/{InstanceId}/{ContactFlowModuleId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the specified flow module. Use the $SAVED alias in the request to describe the SAVED content of a Flow. For example, arn:aws:.../contact-flow/{id}:$SAVED. After a flow is published, $SAVED needs to be supplied to view saved content that has not been published.
    ///
    /// Parameters:
    ///   - contactFlowModuleId: The identifier of the flow module.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeContactFlowModule(
        contactFlowModuleId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeContactFlowModuleResponse {
        let input = DescribeContactFlowModuleRequest(
            contactFlowModuleId: contactFlowModuleId, 
            instanceId: instanceId
        )
        return try await self.describeContactFlowModule(input, logger: logger)
    }

    /// Describe email address form the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func describeEmailAddress(_ input: DescribeEmailAddressRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeEmailAddressResponse {
        try await self.client.execute(
            operation: "DescribeEmailAddress", 
            path: "/email-addresses/{InstanceId}/{EmailAddressId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describe email address form the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - emailAddressId: The identifier of the email address.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeEmailAddress(
        emailAddressId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeEmailAddressResponse {
        let input = DescribeEmailAddressRequest(
            emailAddressId: emailAddressId, 
            instanceId: instanceId
        )
        return try await self.describeEmailAddress(input, logger: logger)
    }

    /// Describes an evaluation form in the specified Amazon Connect instance. If the version property is not provided, the latest version of the evaluation form is described.
    @Sendable
    @inlinable
    public func describeEvaluationForm(_ input: DescribeEvaluationFormRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeEvaluationFormResponse {
        try await self.client.execute(
            operation: "DescribeEvaluationForm", 
            path: "/evaluation-forms/{InstanceId}/{EvaluationFormId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes an evaluation form in the specified Amazon Connect instance. If the version property is not provided, the latest version of the evaluation form is described.
    ///
    /// Parameters:
    ///   - evaluationFormId: A unique identifier for the contact evaluation.
    ///   - evaluationFormVersion: A version of the evaluation form.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeEvaluationForm(
        evaluationFormId: String,
        evaluationFormVersion: Int? = nil,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeEvaluationFormResponse {
        let input = DescribeEvaluationFormRequest(
            evaluationFormId: evaluationFormId, 
            evaluationFormVersion: evaluationFormVersion, 
            instanceId: instanceId
        )
        return try await self.describeEvaluationForm(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Describes the hours of operation.
    @Sendable
    @inlinable
    public func describeHoursOfOperation(_ input: DescribeHoursOfOperationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeHoursOfOperationResponse {
        try await self.client.execute(
            operation: "DescribeHoursOfOperation", 
            path: "/hours-of-operations/{InstanceId}/{HoursOfOperationId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Describes the hours of operation.
    ///
    /// Parameters:
    ///   - hoursOfOperationId: The identifier for the hours of operation.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeHoursOfOperation(
        hoursOfOperationId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeHoursOfOperationResponse {
        let input = DescribeHoursOfOperationRequest(
            hoursOfOperationId: hoursOfOperationId, 
            instanceId: instanceId
        )
        return try await self.describeHoursOfOperation(input, logger: logger)
    }

    /// Describes the hours of operation override.
    @Sendable
    @inlinable
    public func describeHoursOfOperationOverride(_ input: DescribeHoursOfOperationOverrideRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeHoursOfOperationOverrideResponse {
        try await self.client.execute(
            operation: "DescribeHoursOfOperationOverride", 
            path: "/hours-of-operations/{InstanceId}/{HoursOfOperationId}/overrides/{HoursOfOperationOverrideId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the hours of operation override.
    ///
    /// Parameters:
    ///   - hoursOfOperationId: The identifier for the hours of operation.
    ///   - hoursOfOperationOverrideId: The identifier for the hours of operation override.
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeHoursOfOperationOverride(
        hoursOfOperationId: String,
        hoursOfOperationOverrideId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeHoursOfOperationOverrideResponse {
        let input = DescribeHoursOfOperationOverrideRequest(
            hoursOfOperationId: hoursOfOperationId, 
            hoursOfOperationOverrideId: hoursOfOperationOverrideId, 
            instanceId: instanceId
        )
        return try await self.describeHoursOfOperationOverride(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Returns the current state of the specified instance identifier. It tracks the instance while it is being created and returns an error status, if applicable.  If an instance is not created successfully, the instance status reason field returns details relevant to the reason. The instance in a failed state is returned only for 24 hours after the CreateInstance API was invoked.
    @Sendable
    @inlinable
    public func describeInstance(_ input: DescribeInstanceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeInstanceResponse {
        try await self.client.execute(
            operation: "DescribeInstance", 
            path: "/instance/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Returns the current state of the specified instance identifier. It tracks the instance while it is being created and returns an error status, if applicable.  If an instance is not created successfully, the instance status reason field returns details relevant to the reason. The instance in a failed state is returned only for 24 hours after the CreateInstance API was invoked.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeInstance(
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeInstanceResponse {
        let input = DescribeInstanceRequest(
            instanceId: instanceId
        )
        return try await self.describeInstance(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Describes the specified instance attribute.
    @Sendable
    @inlinable
    public func describeInstanceAttribute(_ input: DescribeInstanceAttributeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeInstanceAttributeResponse {
        try await self.client.execute(
            operation: "DescribeInstanceAttribute", 
            path: "/instance/{InstanceId}/attribute/{AttributeType}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Describes the specified instance attribute.
    ///
    /// Parameters:
    ///   - attributeType: The type of attribute.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeInstanceAttribute(
        attributeType: InstanceAttributeType,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeInstanceAttributeResponse {
        let input = DescribeInstanceAttributeRequest(
            attributeType: attributeType, 
            instanceId: instanceId
        )
        return try await self.describeInstanceAttribute(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Retrieves the current storage configurations for the specified resource type, association ID, and instance ID.
    @Sendable
    @inlinable
    public func describeInstanceStorageConfig(_ input: DescribeInstanceStorageConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeInstanceStorageConfigResponse {
        try await self.client.execute(
            operation: "DescribeInstanceStorageConfig", 
            path: "/instance/{InstanceId}/storage-config/{AssociationId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Retrieves the current storage configurations for the specified resource type, association ID, and instance ID.
    ///
    /// Parameters:
    ///   - associationId: The existing association identifier that uniquely identifies the resource type and storage config for the given instance ID.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - resourceType: A valid resource type.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeInstanceStorageConfig(
        associationId: String,
        instanceId: String,
        resourceType: InstanceStorageResourceType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeInstanceStorageConfigResponse {
        let input = DescribeInstanceStorageConfigRequest(
            associationId: associationId, 
            instanceId: instanceId, 
            resourceType: resourceType
        )
        return try await self.describeInstanceStorageConfig(input, logger: logger)
    }

    /// Gets details and status of a phone number that’s claimed to your Amazon Connect instance or traffic distribution group.  If the number is claimed to a traffic distribution group, and you are calling in the Amazon Web Services Region where the traffic distribution group was created, you can use either a phone number ARN or UUID value for the PhoneNumberId URI request parameter. However, if the number is claimed to a traffic distribution group and you are calling this API in the alternate Amazon Web Services Region associated with the traffic distribution group, you must provide a full phone number ARN. If a UUID is provided in this scenario, you receive a ResourceNotFoundException.
    @Sendable
    @inlinable
    public func describePhoneNumber(_ input: DescribePhoneNumberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribePhoneNumberResponse {
        try await self.client.execute(
            operation: "DescribePhoneNumber", 
            path: "/phone-number/{PhoneNumberId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets details and status of a phone number that’s claimed to your Amazon Connect instance or traffic distribution group.  If the number is claimed to a traffic distribution group, and you are calling in the Amazon Web Services Region where the traffic distribution group was created, you can use either a phone number ARN or UUID value for the PhoneNumberId URI request parameter. However, if the number is claimed to a traffic distribution group and you are calling this API in the alternate Amazon Web Services Region associated with the traffic distribution group, you must provide a full phone number ARN. If a UUID is provided in this scenario, you receive a ResourceNotFoundException.
    ///
    /// Parameters:
    ///   - phoneNumberId: A unique identifier for the phone number.
    ///   - logger: Logger use during operation
    @inlinable
    public func describePhoneNumber(
        phoneNumberId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribePhoneNumberResponse {
        let input = DescribePhoneNumberRequest(
            phoneNumberId: phoneNumberId
        )
        return try await self.describePhoneNumber(input, logger: logger)
    }

    /// Describes a predefined attribute for the specified Amazon Connect instance. Predefined attributes are attributes in an Amazon Connect instance that can be used to route contacts to an agent or pools of agents within a queue. For more information, see Create predefined attributes for routing contacts to agents.
    @Sendable
    @inlinable
    public func describePredefinedAttribute(_ input: DescribePredefinedAttributeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribePredefinedAttributeResponse {
        try await self.client.execute(
            operation: "DescribePredefinedAttribute", 
            path: "/predefined-attributes/{InstanceId}/{Name}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes a predefined attribute for the specified Amazon Connect instance. Predefined attributes are attributes in an Amazon Connect instance that can be used to route contacts to an agent or pools of agents within a queue. For more information, see Create predefined attributes for routing contacts to agents.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the predefined attribute.
    ///   - logger: Logger use during operation
    @inlinable
    public func describePredefinedAttribute(
        instanceId: String,
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribePredefinedAttributeResponse {
        let input = DescribePredefinedAttributeRequest(
            instanceId: instanceId, 
            name: name
        )
        return try await self.describePredefinedAttribute(input, logger: logger)
    }

    /// Describes the prompt.
    @Sendable
    @inlinable
    public func describePrompt(_ input: DescribePromptRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribePromptResponse {
        try await self.client.execute(
            operation: "DescribePrompt", 
            path: "/prompts/{InstanceId}/{PromptId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the prompt.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - promptId: A unique identifier for the prompt.
    ///   - logger: Logger use during operation
    @inlinable
    public func describePrompt(
        instanceId: String,
        promptId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribePromptResponse {
        let input = DescribePromptRequest(
            instanceId: instanceId, 
            promptId: promptId
        )
        return try await self.describePrompt(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Describes the specified queue.
    @Sendable
    @inlinable
    public func describeQueue(_ input: DescribeQueueRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeQueueResponse {
        try await self.client.execute(
            operation: "DescribeQueue", 
            path: "/queues/{InstanceId}/{QueueId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Describes the specified queue.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - queueId: The identifier for the queue.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeQueue(
        instanceId: String,
        queueId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeQueueResponse {
        let input = DescribeQueueRequest(
            instanceId: instanceId, 
            queueId: queueId
        )
        return try await self.describeQueue(input, logger: logger)
    }

    /// Describes the quick connect.
    @Sendable
    @inlinable
    public func describeQuickConnect(_ input: DescribeQuickConnectRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeQuickConnectResponse {
        try await self.client.execute(
            operation: "DescribeQuickConnect", 
            path: "/quick-connects/{InstanceId}/{QuickConnectId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the quick connect.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - quickConnectId: The identifier for the quick connect.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeQuickConnect(
        instanceId: String,
        quickConnectId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeQuickConnectResponse {
        let input = DescribeQuickConnectRequest(
            instanceId: instanceId, 
            quickConnectId: quickConnectId
        )
        return try await self.describeQuickConnect(input, logger: logger)
    }

    /// Describes the specified routing profile.   DescribeRoutingProfile does not populate AssociatedQueueIds in its response. The example Response Syntax shown on this page is incorrect; we are working to update it. SearchRoutingProfiles does include AssociatedQueueIds.
    @Sendable
    @inlinable
    public func describeRoutingProfile(_ input: DescribeRoutingProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeRoutingProfileResponse {
        try await self.client.execute(
            operation: "DescribeRoutingProfile", 
            path: "/routing-profiles/{InstanceId}/{RoutingProfileId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the specified routing profile.   DescribeRoutingProfile does not populate AssociatedQueueIds in its response. The example Response Syntax shown on this page is incorrect; we are working to update it. SearchRoutingProfiles does include AssociatedQueueIds.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - routingProfileId: The identifier of the routing profile.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeRoutingProfile(
        instanceId: String,
        routingProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeRoutingProfileResponse {
        let input = DescribeRoutingProfileRequest(
            instanceId: instanceId, 
            routingProfileId: routingProfileId
        )
        return try await self.describeRoutingProfile(input, logger: logger)
    }

    /// Describes a rule for the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func describeRule(_ input: DescribeRuleRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeRuleResponse {
        try await self.client.execute(
            operation: "DescribeRule", 
            path: "/rules/{InstanceId}/{RuleId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes a rule for the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - ruleId: A unique identifier for the rule.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeRule(
        instanceId: String,
        ruleId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeRuleResponse {
        let input = DescribeRuleRequest(
            instanceId: instanceId, 
            ruleId: ruleId
        )
        return try await self.describeRule(input, logger: logger)
    }

    /// Gets basic information about the security profile. For information about security profiles, see Security Profiles in the Amazon Connect Administrator Guide. For a mapping of the API name and user interface name of the security profile permissions, see List of security profile permissions.
    @Sendable
    @inlinable
    public func describeSecurityProfile(_ input: DescribeSecurityProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeSecurityProfileResponse {
        try await self.client.execute(
            operation: "DescribeSecurityProfile", 
            path: "/security-profiles/{InstanceId}/{SecurityProfileId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets basic information about the security profile. For information about security profiles, see Security Profiles in the Amazon Connect Administrator Guide. For a mapping of the API name and user interface name of the security profile permissions, see List of security profile permissions.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - securityProfileId: The identifier for the security profle.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeSecurityProfile(
        instanceId: String,
        securityProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeSecurityProfileResponse {
        let input = DescribeSecurityProfileRequest(
            instanceId: instanceId, 
            securityProfileId: securityProfileId
        )
        return try await self.describeSecurityProfile(input, logger: logger)
    }

    /// Gets details and status of a traffic distribution group.
    @Sendable
    @inlinable
    public func describeTrafficDistributionGroup(_ input: DescribeTrafficDistributionGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeTrafficDistributionGroupResponse {
        try await self.client.execute(
            operation: "DescribeTrafficDistributionGroup", 
            path: "/traffic-distribution-group/{TrafficDistributionGroupId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets details and status of a traffic distribution group.
    ///
    /// Parameters:
    ///   - trafficDistributionGroupId: The identifier of the traffic distribution group.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeTrafficDistributionGroup(
        trafficDistributionGroupId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeTrafficDistributionGroupResponse {
        let input = DescribeTrafficDistributionGroupRequest(
            trafficDistributionGroupId: trafficDistributionGroupId
        )
        return try await self.describeTrafficDistributionGroup(input, logger: logger)
    }

    /// Describes the specified user. You can find the instance ID in the Amazon Connect console (it’s the final part of the ARN). The console does not display the user IDs. Instead, list the users and note the IDs provided in the output.
    @Sendable
    @inlinable
    public func describeUser(_ input: DescribeUserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeUserResponse {
        try await self.client.execute(
            operation: "DescribeUser", 
            path: "/users/{InstanceId}/{UserId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the specified user. You can find the instance ID in the Amazon Connect console (it’s the final part of the ARN). The console does not display the user IDs. Instead, list the users and note the IDs provided in the output.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - userId: The identifier of the user account.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeUser(
        instanceId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeUserResponse {
        let input = DescribeUserRequest(
            instanceId: instanceId, 
            userId: userId
        )
        return try await self.describeUser(input, logger: logger)
    }

    /// Describes the specified hierarchy group.
    @Sendable
    @inlinable
    public func describeUserHierarchyGroup(_ input: DescribeUserHierarchyGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeUserHierarchyGroupResponse {
        try await self.client.execute(
            operation: "DescribeUserHierarchyGroup", 
            path: "/user-hierarchy-groups/{InstanceId}/{HierarchyGroupId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the specified hierarchy group.
    ///
    /// Parameters:
    ///   - hierarchyGroupId: The identifier of the hierarchy group.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeUserHierarchyGroup(
        hierarchyGroupId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeUserHierarchyGroupResponse {
        let input = DescribeUserHierarchyGroupRequest(
            hierarchyGroupId: hierarchyGroupId, 
            instanceId: instanceId
        )
        return try await self.describeUserHierarchyGroup(input, logger: logger)
    }

    /// Describes the hierarchy structure of the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func describeUserHierarchyStructure(_ input: DescribeUserHierarchyStructureRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeUserHierarchyStructureResponse {
        try await self.client.execute(
            operation: "DescribeUserHierarchyStructure", 
            path: "/user-hierarchy-structure/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the hierarchy structure of the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeUserHierarchyStructure(
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeUserHierarchyStructureResponse {
        let input = DescribeUserHierarchyStructureRequest(
            instanceId: instanceId
        )
        return try await self.describeUserHierarchyStructure(input, logger: logger)
    }

    /// Retrieves the view for the specified Amazon Connect instance and view identifier. The view identifier can be supplied as a ViewId or ARN.  $SAVED needs to be supplied if a view is unpublished. The view identifier can contain an optional qualifier, for example, :$SAVED, which is either an actual version number or an Amazon Connect managed qualifier $SAVED | $LATEST. If it is not supplied, then $LATEST is assumed for customer managed views and an error is returned if there is no published content available. Version 1 is assumed for Amazon Web Services managed views.
    @Sendable
    @inlinable
    public func describeView(_ input: DescribeViewRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeViewResponse {
        try await self.client.execute(
            operation: "DescribeView", 
            path: "/views/{InstanceId}/{ViewId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the view for the specified Amazon Connect instance and view identifier. The view identifier can be supplied as a ViewId or ARN.  $SAVED needs to be supplied if a view is unpublished. The view identifier can contain an optional qualifier, for example, :$SAVED, which is either an actual version number or an Amazon Connect managed qualifier $SAVED | $LATEST. If it is not supplied, then $LATEST is assumed for customer managed views and an error is returned if there is no published content available. Version 1 is assumed for Amazon Web Services managed views.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - viewId: The ViewId of the view. This must be an ARN for Amazon Web Services managed views.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeView(
        instanceId: String,
        viewId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeViewResponse {
        let input = DescribeViewRequest(
            instanceId: instanceId, 
            viewId: viewId
        )
        return try await self.describeView(input, logger: logger)
    }

    /// Describes the specified vocabulary.
    @Sendable
    @inlinable
    public func describeVocabulary(_ input: DescribeVocabularyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeVocabularyResponse {
        try await self.client.execute(
            operation: "DescribeVocabulary", 
            path: "/vocabulary/{InstanceId}/{VocabularyId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the specified vocabulary.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - vocabularyId: The identifier of the custom vocabulary.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeVocabulary(
        instanceId: String,
        vocabularyId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeVocabularyResponse {
        let input = DescribeVocabularyRequest(
            instanceId: instanceId, 
            vocabularyId: vocabularyId
        )
        return try await self.describeVocabulary(input, logger: logger)
    }

    /// Removes the dataset ID associated with a given Amazon Connect instance.
    @Sendable
    @inlinable
    public func disassociateAnalyticsDataSet(_ input: DisassociateAnalyticsDataSetRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DisassociateAnalyticsDataSet", 
            path: "/analytics-data/instance/{InstanceId}/association", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the dataset ID associated with a given Amazon Connect instance.
    ///
    /// Parameters:
    ///   - dataSetId: The identifier of the dataset to remove.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - targetAccountId: The identifier of the target account.  Use to associate a dataset to a different account than the one containing the Amazon Connect instance. If not specified, by default this value is the Amazon Web Services account that has the Amazon Connect instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateAnalyticsDataSet(
        dataSetId: String,
        instanceId: String,
        targetAccountId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DisassociateAnalyticsDataSetRequest(
            dataSetId: dataSetId, 
            instanceId: instanceId, 
            targetAccountId: targetAccountId
        )
        return try await self.disassociateAnalyticsDataSet(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Revokes access to integrated applications from Amazon Connect.
    @Sendable
    @inlinable
    public func disassociateApprovedOrigin(_ input: DisassociateApprovedOriginRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DisassociateApprovedOrigin", 
            path: "/instance/{InstanceId}/approved-origin", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Revokes access to integrated applications from Amazon Connect.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - origin: The domain URL of the integrated application.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateApprovedOrigin(
        clientToken: String? = DisassociateApprovedOriginRequest.idempotencyToken(),
        instanceId: String,
        origin: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DisassociateApprovedOriginRequest(
            clientToken: clientToken, 
            instanceId: instanceId, 
            origin: origin
        )
        return try await self.disassociateApprovedOrigin(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Revokes authorization from the specified instance to access the specified Amazon Lex or Amazon Lex V2 bot.
    @Sendable
    @inlinable
    public func disassociateBot(_ input: DisassociateBotRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DisassociateBot", 
            path: "/instance/{InstanceId}/bot", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Revokes authorization from the specified instance to access the specified Amazon Lex or Amazon Lex V2 bot.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - lexBot: 
    ///   - lexV2Bot: The Amazon Lex V2 bot to disassociate from the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateBot(
        clientToken: String? = DisassociateBotRequest.idempotencyToken(),
        instanceId: String,
        lexBot: LexBot? = nil,
        lexV2Bot: LexV2Bot? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DisassociateBotRequest(
            clientToken: clientToken, 
            instanceId: instanceId, 
            lexBot: lexBot, 
            lexV2Bot: lexV2Bot
        )
        return try await self.disassociateBot(input, logger: logger)
    }

    /// Disassociates a connect resource from a flow.
    @Sendable
    @inlinable
    public func disassociateFlow(_ input: DisassociateFlowRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateFlowResponse {
        try await self.client.execute(
            operation: "DisassociateFlow", 
            path: "/flow-associations/{InstanceId}/{ResourceId}/{ResourceType}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates a connect resource from a flow.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - resourceId: The identifier of the resource.   Amazon Web Services End User Messaging SMS phone number ARN when using SMS_PHONE_NUMBER    Amazon Web Services End User Messaging Social phone number ARN when using WHATSAPP_MESSAGING_PHONE_NUMBER
    ///   - resourceType: A valid resource type.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateFlow(
        instanceId: String,
        resourceId: String,
        resourceType: FlowAssociationResourceType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateFlowResponse {
        let input = DisassociateFlowRequest(
            instanceId: instanceId, 
            resourceId: resourceId, 
            resourceType: resourceType
        )
        return try await self.disassociateFlow(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Removes the storage type configurations for the specified resource type and association ID.
    @Sendable
    @inlinable
    public func disassociateInstanceStorageConfig(_ input: DisassociateInstanceStorageConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DisassociateInstanceStorageConfig", 
            path: "/instance/{InstanceId}/storage-config/{AssociationId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Removes the storage type configurations for the specified resource type and association ID.
    ///
    /// Parameters:
    ///   - associationId: The existing association identifier that uniquely identifies the resource type and storage config for the given instance ID.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - resourceType: A valid resource type.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateInstanceStorageConfig(
        associationId: String,
        clientToken: String? = DisassociateInstanceStorageConfigRequest.idempotencyToken(),
        instanceId: String,
        resourceType: InstanceStorageResourceType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DisassociateInstanceStorageConfigRequest(
            associationId: associationId, 
            clientToken: clientToken, 
            instanceId: instanceId, 
            resourceType: resourceType
        )
        return try await self.disassociateInstanceStorageConfig(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Remove the Lambda function from the dropdown options available in the relevant flow blocks.
    @Sendable
    @inlinable
    public func disassociateLambdaFunction(_ input: DisassociateLambdaFunctionRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DisassociateLambdaFunction", 
            path: "/instance/{InstanceId}/lambda-function", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Remove the Lambda function from the dropdown options available in the relevant flow blocks.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - functionArn: The Amazon Resource Name (ARN) of the Lambda function being disassociated.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance..
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateLambdaFunction(
        clientToken: String? = DisassociateLambdaFunctionRequest.idempotencyToken(),
        functionArn: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DisassociateLambdaFunctionRequest(
            clientToken: clientToken, 
            functionArn: functionArn, 
            instanceId: instanceId
        )
        return try await self.disassociateLambdaFunction(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Revokes authorization from the specified instance to access the specified Amazon Lex bot.
    @Sendable
    @inlinable
    public func disassociateLexBot(_ input: DisassociateLexBotRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DisassociateLexBot", 
            path: "/instance/{InstanceId}/lex-bot", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Revokes authorization from the specified instance to access the specified Amazon Lex bot.
    ///
    /// Parameters:
    ///   - botName: The name of the Amazon Lex bot. Maximum character limit of 50.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - lexRegion: The Amazon Web Services Region in which the Amazon Lex bot has been created.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateLexBot(
        botName: String,
        clientToken: String? = DisassociateLexBotRequest.idempotencyToken(),
        instanceId: String,
        lexRegion: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DisassociateLexBotRequest(
            botName: botName, 
            clientToken: clientToken, 
            instanceId: instanceId, 
            lexRegion: lexRegion
        )
        return try await self.disassociateLexBot(input, logger: logger)
    }

    /// Removes the flow association from a phone number claimed to your Amazon Connect instance.  If the number is claimed to a traffic distribution group, and you are calling this API using an instance in the Amazon Web Services Region where the traffic distribution group was created, you can use either a full phone number ARN or UUID value for the PhoneNumberId URI request parameter. However, if the number is claimed to a traffic distribution group and you are calling this API using an instance in the alternate Amazon Web Services Region associated with the traffic distribution group, you must provide a full phone number ARN. If a UUID is provided in this scenario, you will receive a ResourceNotFoundException.
    @Sendable
    @inlinable
    public func disassociatePhoneNumberContactFlow(_ input: DisassociatePhoneNumberContactFlowRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DisassociatePhoneNumberContactFlow", 
            path: "/phone-number/{PhoneNumberId}/contact-flow", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the flow association from a phone number claimed to your Amazon Connect instance.  If the number is claimed to a traffic distribution group, and you are calling this API using an instance in the Amazon Web Services Region where the traffic distribution group was created, you can use either a full phone number ARN or UUID value for the PhoneNumberId URI request parameter. However, if the number is claimed to a traffic distribution group and you are calling this API using an instance in the alternate Amazon Web Services Region associated with the traffic distribution group, you must provide a full phone number ARN. If a UUID is provided in this scenario, you will receive a ResourceNotFoundException.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - phoneNumberId: A unique identifier for the phone number.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociatePhoneNumberContactFlow(
        instanceId: String,
        phoneNumberId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DisassociatePhoneNumberContactFlowRequest(
            instanceId: instanceId, 
            phoneNumberId: phoneNumberId
        )
        return try await self.disassociatePhoneNumberContactFlow(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Disassociates a set of quick connects from a queue.
    @Sendable
    @inlinable
    public func disassociateQueueQuickConnects(_ input: DisassociateQueueQuickConnectsRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DisassociateQueueQuickConnects", 
            path: "/queues/{InstanceId}/{QueueId}/disassociate-quick-connects", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Disassociates a set of quick connects from a queue.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - queueId: The identifier for the queue.
    ///   - quickConnectIds: The quick connects to disassociate from the queue.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateQueueQuickConnects(
        instanceId: String,
        queueId: String,
        quickConnectIds: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DisassociateQueueQuickConnectsRequest(
            instanceId: instanceId, 
            queueId: queueId, 
            quickConnectIds: quickConnectIds
        )
        return try await self.disassociateQueueQuickConnects(input, logger: logger)
    }

    /// Disassociates a set of queues from a routing profile.
    @Sendable
    @inlinable
    public func disassociateRoutingProfileQueues(_ input: DisassociateRoutingProfileQueuesRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DisassociateRoutingProfileQueues", 
            path: "/routing-profiles/{InstanceId}/{RoutingProfileId}/disassociate-queues", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates a set of queues from a routing profile.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - queueReferences: The queues to disassociate from this routing profile.
    ///   - routingProfileId: The identifier of the routing profile.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateRoutingProfileQueues(
        instanceId: String,
        queueReferences: [RoutingProfileQueueReference],
        routingProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DisassociateRoutingProfileQueuesRequest(
            instanceId: instanceId, 
            queueReferences: queueReferences, 
            routingProfileId: routingProfileId
        )
        return try await self.disassociateRoutingProfileQueues(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Deletes the specified security key.
    @Sendable
    @inlinable
    public func disassociateSecurityKey(_ input: DisassociateSecurityKeyRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DisassociateSecurityKey", 
            path: "/instance/{InstanceId}/security-key/{AssociationId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Deletes the specified security key.
    ///
    /// Parameters:
    ///   - associationId: The existing association identifier that uniquely identifies the resource type and storage config for the given instance ID.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateSecurityKey(
        associationId: String,
        clientToken: String? = DisassociateSecurityKeyRequest.idempotencyToken(),
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DisassociateSecurityKeyRequest(
            associationId: associationId, 
            clientToken: clientToken, 
            instanceId: instanceId
        )
        return try await self.disassociateSecurityKey(input, logger: logger)
    }

    /// Disassociates an agent from a traffic distribution group. This API can be called only in the Region where the traffic distribution group is created.
    @Sendable
    @inlinable
    public func disassociateTrafficDistributionGroupUser(_ input: DisassociateTrafficDistributionGroupUserRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateTrafficDistributionGroupUserResponse {
        try await self.client.execute(
            operation: "DisassociateTrafficDistributionGroupUser", 
            path: "/traffic-distribution-group/{TrafficDistributionGroupId}/user", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates an agent from a traffic distribution group. This API can be called only in the Region where the traffic distribution group is created.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - trafficDistributionGroupId: The identifier of the traffic distribution group.
    ///   - userId: The identifier for the user. This can be the ID or the ARN of the user.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateTrafficDistributionGroupUser(
        instanceId: String,
        trafficDistributionGroupId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateTrafficDistributionGroupUserResponse {
        let input = DisassociateTrafficDistributionGroupUserRequest(
            instanceId: instanceId, 
            trafficDistributionGroupId: trafficDistributionGroupId, 
            userId: userId
        )
        return try await self.disassociateTrafficDistributionGroupUser(input, logger: logger)
    }

    /// Disassociates a set of proficiencies from a user.
    @Sendable
    @inlinable
    public func disassociateUserProficiencies(_ input: DisassociateUserProficienciesRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DisassociateUserProficiencies", 
            path: "/users/{InstanceId}/{UserId}/disassociate-proficiencies", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates a set of proficiencies from a user.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - userId: The identifier of the user account.
    ///   - userProficiencies: The proficiencies to disassociate from the user.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateUserProficiencies(
        instanceId: String,
        userId: String,
        userProficiencies: [UserProficiencyDisassociate],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DisassociateUserProficienciesRequest(
            instanceId: instanceId, 
            userId: userId, 
            userProficiencies: userProficiencies
        )
        return try await self.disassociateUserProficiencies(input, logger: logger)
    }

    /// Dismisses contacts from an agent’s CCP and returns the agent to an available state, which allows the agent to receive a new routed contact. Contacts can only be dismissed if they are in a MISSED, ERROR, ENDED, or REJECTED state in the Agent Event Stream.
    @Sendable
    @inlinable
    public func dismissUserContact(_ input: DismissUserContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DismissUserContactResponse {
        try await self.client.execute(
            operation: "DismissUserContact", 
            path: "/users/{InstanceId}/{UserId}/contact", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Dismisses contacts from an agent’s CCP and returns the agent to an available state, which allows the agent to receive a new routed contact. Contacts can only be dismissed if they are in a MISSED, ERROR, ENDED, or REJECTED state in the Agent Event Stream.
    ///
    /// Parameters:
    ///   - contactId: The identifier of the contact.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - userId: The identifier of the user account.
    ///   - logger: Logger use during operation
    @inlinable
    public func dismissUserContact(
        contactId: String,
        instanceId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DismissUserContactResponse {
        let input = DismissUserContactRequest(
            contactId: contactId, 
            instanceId: instanceId, 
            userId: userId
        )
        return try await self.dismissUserContact(input, logger: logger)
    }

    /// Provides a pre-signed URL for download of an approved attached file. This API also returns metadata about the attached file. It will only return a downloadURL if the status of the attached file is APPROVED.
    @Sendable
    @inlinable
    public func getAttachedFile(_ input: GetAttachedFileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAttachedFileResponse {
        try await self.client.execute(
            operation: "GetAttachedFile", 
            path: "/attached-files/{InstanceId}/{FileId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides a pre-signed URL for download of an approved attached file. This API also returns metadata about the attached file. It will only return a downloadURL if the status of the attached file is APPROVED.
    ///
    /// Parameters:
    ///   - associatedResourceArn: The resource to which the attached file is (being) uploaded to. The supported resources are Cases and Email.  This value must be a valid ARN.
    ///   - fileId: The unique identifier of the attached file resource.
    ///   - instanceId: The unique identifier of the Amazon Connect instance.
    ///   - urlExpiryInSeconds: Optional override for the expiry of the pre-signed S3 URL in seconds. The default value is 300.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAttachedFile(
        associatedResourceArn: String,
        fileId: String,
        instanceId: String,
        urlExpiryInSeconds: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAttachedFileResponse {
        let input = GetAttachedFileRequest(
            associatedResourceArn: associatedResourceArn, 
            fileId: fileId, 
            instanceId: instanceId, 
            urlExpiryInSeconds: urlExpiryInSeconds
        )
        return try await self.getAttachedFile(input, logger: logger)
    }

    /// Retrieves the contact attributes for the specified contact.
    @Sendable
    @inlinable
    public func getContactAttributes(_ input: GetContactAttributesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetContactAttributesResponse {
        try await self.client.execute(
            operation: "GetContactAttributes", 
            path: "/contact/attributes/{InstanceId}/{InitialContactId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the contact attributes for the specified contact.
    ///
    /// Parameters:
    ///   - initialContactId: The identifier of the initial contact.
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func getContactAttributes(
        initialContactId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetContactAttributesResponse {
        let input = GetContactAttributesRequest(
            initialContactId: initialContactId, 
            instanceId: instanceId
        )
        return try await self.getContactAttributes(input, logger: logger)
    }

    /// Gets the real-time metric data from the specified Amazon Connect instance. For a description of each metric, see Metrics definitions in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func getCurrentMetricData(_ input: GetCurrentMetricDataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCurrentMetricDataResponse {
        try await self.client.execute(
            operation: "GetCurrentMetricData", 
            path: "/metrics/current/{InstanceId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the real-time metric data from the specified Amazon Connect instance. For a description of each metric, see Metrics definitions in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - currentMetrics: The metrics to retrieve. Specify the name and unit for each metric. The following metrics are available. For a description of all the metrics, see Metrics definitions in the Amazon Connect Administrator Guide.  AGENTS_AFTER_CONTACT_WORK  Unit: COUNT Name in real-time metrics report: ACW   AGENTS_AVAILABLE  Unit: COUNT Name in real-time metrics report: Available   AGENTS_ERROR  Unit: COUNT Name in real-time metrics report: Error   AGENTS_NON_PRODUCTIVE  Unit: COUNT Name in real-time metrics report: NPT (Non-Productive Time)   AGENTS_ON_CALL  Unit: COUNT Name in real-time metrics report: On contact   AGENTS_ON_CONTACT  Unit: COUNT Name in real-time metrics report: On contact   AGENTS_ONLINE  Unit: COUNT Name in real-time metrics report: Online   AGENTS_STAFFED  Unit: COUNT Name in real-time metrics report: Staffed   CONTACTS_IN_QUEUE  Unit: COUNT Name in real-time metrics report: In queue   CONTACTS_SCHEDULED  Unit: COUNT Name in real-time metrics report: Scheduled   OLDEST_CONTACT_AGE  Unit: SECONDS When you use groupings, Unit says SECONDS and the Value is returned in SECONDS.  When you do not use groupings, Unit says SECONDS but the Value is returned in MILLISECONDS. For example, if you get a response like this:  { "Metric": { "Name": "OLDEST_CONTACT_AGE", "Unit": "SECONDS" }, "Value": 24113.0 } The actual OLDEST_CONTACT_AGE is 24 seconds. When the filter RoutingStepExpression is used, this metric is still calculated from enqueue time. For example, if a contact that has been queued under for 10 seconds has expired and  becomes active, then OLDEST_CONTACT_AGE for this queue will be counted starting from 10, not 0. Name in real-time metrics report: Oldest   SLOTS_ACTIVE  Unit: COUNT Name in real-time metrics report: Active   SLOTS_AVAILABLE  Unit: COUNT Name in real-time metrics report: Availability
    ///   - filters: The filters to apply to returned metrics. You can filter up to the following limits:   Queues: 100   Routing profiles: 100   Channels: 3 (VOICE, CHAT, and TASK channels are supported.)   RoutingStepExpressions: 50   Metric data is retrieved only for the resources associated with the queues or routing profiles, and by any channels included in the filter. (You cannot filter by both queue AND routing profile.) You can include both resource IDs and resource ARNs in the same request. When using the RoutingStepExpression filter, you need to pass exactly one QueueId. The filter is also case sensitive so when using the RoutingStepExpression filter, grouping by ROUTING_STEP_EXPRESSION is required. Currently tagging is only supported on the resources that are passed in the filter.
    ///   - groupings: The grouping applied to the metrics returned. For example, when grouped by QUEUE, the metrics returned apply to each queue rather than aggregated for all queues.    If you group by CHANNEL, you should include a Channels filter. VOICE, CHAT, and TASK channels are supported.   If you group by ROUTING_PROFILE, you must include either a queue or routing profile filter. In addition, a routing profile filter is required for metrics CONTACTS_SCHEDULED, CONTACTS_IN_QUEUE, and  OLDEST_CONTACT_AGE.   If no Grouping is included in the request, a summary of metrics is returned.   When using the RoutingStepExpression filter, group by ROUTING_STEP_EXPRESSION is required.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - sortCriteria: The way to sort the resulting response based on metrics. You can enter one sort criteria. By default resources are sorted based on AGENTS_ONLINE, DESCENDING. The metric collection is sorted based on the input metrics. Note the following:   Sorting on SLOTS_ACTIVE and SLOTS_AVAILABLE is not supported.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCurrentMetricData(
        currentMetrics: [CurrentMetric],
        filters: Filters,
        groupings: [Grouping]? = nil,
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        sortCriteria: [CurrentMetricSortCriteria]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCurrentMetricDataResponse {
        let input = GetCurrentMetricDataRequest(
            currentMetrics: currentMetrics, 
            filters: filters, 
            groupings: groupings, 
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            sortCriteria: sortCriteria
        )
        return try await self.getCurrentMetricData(input, logger: logger)
    }

    /// Gets the real-time active user data from the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func getCurrentUserData(_ input: GetCurrentUserDataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCurrentUserDataResponse {
        try await self.client.execute(
            operation: "GetCurrentUserData", 
            path: "/metrics/userdata/{InstanceId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the real-time active user data from the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - filters: The filters to apply to returned user data. You can filter up to the following limits:   Queues: 100   Routing profiles: 100   Agents: 100   Contact states: 9   User hierarchy groups: 1   The user data is retrieved for only the specified values/resources in the filter. A maximum of one filter can be passed from queues, routing profiles, agents, and user hierarchy groups.  Currently tagging is only supported on the resources that are passed in the filter.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func getCurrentUserData(
        filters: UserDataFilters,
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCurrentUserDataResponse {
        let input = GetCurrentUserDataRequest(
            filters: filters, 
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.getCurrentUserData(input, logger: logger)
    }

    /// Get the hours of operations with the effective override applied.
    @Sendable
    @inlinable
    public func getEffectiveHoursOfOperations(_ input: GetEffectiveHoursOfOperationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEffectiveHoursOfOperationsResponse {
        try await self.client.execute(
            operation: "GetEffectiveHoursOfOperations", 
            path: "/effective-hours-of-operations/{InstanceId}/{HoursOfOperationId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get the hours of operations with the effective override applied.
    ///
    /// Parameters:
    ///   - fromDate: The Date from when the hours of operation are listed.
    ///   - hoursOfOperationId: The identifier for the hours of operation.
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - toDate: The Date until when the hours of operation are listed.
    ///   - logger: Logger use during operation
    @inlinable
    public func getEffectiveHoursOfOperations(
        fromDate: String,
        hoursOfOperationId: String,
        instanceId: String,
        toDate: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEffectiveHoursOfOperationsResponse {
        let input = GetEffectiveHoursOfOperationsRequest(
            fromDate: fromDate, 
            hoursOfOperationId: hoursOfOperationId, 
            instanceId: instanceId, 
            toDate: toDate
        )
        return try await self.getEffectiveHoursOfOperations(input, logger: logger)
    }

    /// Supports SAML sign-in for Amazon Connect. Retrieves a token for federation. The token is for the Amazon Connect user which corresponds to the IAM credentials that were used to invoke this action.  For more information about how SAML sign-in works in Amazon Connect, see Configure SAML with IAM for Amazon Connect in the Amazon Connect Administrator Guide.   This API doesn't support root users. If you try to invoke GetFederationToken with root credentials, an error message similar to the following one appears:   Provided identity: Principal: .... User: .... cannot be used for federation with Amazon Connect
    @Sendable
    @inlinable
    public func getFederationToken(_ input: GetFederationTokenRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetFederationTokenResponse {
        try await self.client.execute(
            operation: "GetFederationToken", 
            path: "/user/federate/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Supports SAML sign-in for Amazon Connect. Retrieves a token for federation. The token is for the Amazon Connect user which corresponds to the IAM credentials that were used to invoke this action.  For more information about how SAML sign-in works in Amazon Connect, see Configure SAML with IAM for Amazon Connect in the Amazon Connect Administrator Guide.   This API doesn't support root users. If you try to invoke GetFederationToken with root credentials, an error message similar to the following one appears:   Provided identity: Principal: .... User: .... cannot be used for federation with Amazon Connect
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func getFederationToken(
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetFederationTokenResponse {
        let input = GetFederationTokenRequest(
            instanceId: instanceId
        )
        return try await self.getFederationToken(input, logger: logger)
    }

    /// Retrieves the flow associated for a given resource.
    @Sendable
    @inlinable
    public func getFlowAssociation(_ input: GetFlowAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetFlowAssociationResponse {
        try await self.client.execute(
            operation: "GetFlowAssociation", 
            path: "/flow-associations/{InstanceId}/{ResourceId}/{ResourceType}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the flow associated for a given resource.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - resourceId: The identifier of the resource.   Amazon Web Services End User Messaging SMS phone number ARN when using SMS_PHONE_NUMBER    Amazon Web Services End User Messaging Social phone number ARN when using WHATSAPP_MESSAGING_PHONE_NUMBER
    ///   - resourceType: A valid resource type.
    ///   - logger: Logger use during operation
    @inlinable
    public func getFlowAssociation(
        instanceId: String,
        resourceId: String,
        resourceType: FlowAssociationResourceType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetFlowAssociationResponse {
        let input = GetFlowAssociationRequest(
            instanceId: instanceId, 
            resourceId: resourceId, 
            resourceType: resourceType
        )
        return try await self.getFlowAssociation(input, logger: logger)
    }

    /// Gets historical metric data from the specified Amazon Connect instance. For a description of each historical metric, see Metrics definitions in the Amazon Connect Administrator Guide.  We recommend using the GetMetricDataV2 API. It provides more flexibility, features, and the ability to query longer time ranges than GetMetricData. Use it to retrieve historical agent and contact metrics for the last 3 months, at varying intervals. You can also use it to build custom dashboards to measure historical queue and agent performance. For example, you can track the number of incoming contacts for the last 7 days, with data split by day, to see how contact volume changed per day of the week.
    @Sendable
    @inlinable
    public func getMetricData(_ input: GetMetricDataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMetricDataResponse {
        try await self.client.execute(
            operation: "GetMetricData", 
            path: "/metrics/historical/{InstanceId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets historical metric data from the specified Amazon Connect instance. For a description of each historical metric, see Metrics definitions in the Amazon Connect Administrator Guide.  We recommend using the GetMetricDataV2 API. It provides more flexibility, features, and the ability to query longer time ranges than GetMetricData. Use it to retrieve historical agent and contact metrics for the last 3 months, at varying intervals. You can also use it to build custom dashboards to measure historical queue and agent performance. For example, you can track the number of incoming contacts for the last 7 days, with data split by day, to see how contact volume changed per day of the week.
    ///
    /// Parameters:
    ///   - endTime: The timestamp, in UNIX Epoch time format, at which to end the reporting interval for the retrieval of historical metrics data. The time must be specified using an interval of 5 minutes, such as 11:00, 11:05, 11:10, and must be later than the start time timestamp. The time range between the start and end time must be less than 24 hours.
    ///   - filters: The queues, up to 100, or channels, to use to filter the metrics returned. Metric data is retrieved only for the resources associated with the queues or channels included in the filter. You can include both queue IDs and queue ARNs in the same request. VOICE, CHAT, and TASK channels are supported. RoutingStepExpression is not a valid filter for GetMetricData and we recommend switching to GetMetricDataV2 for more up-to-date features.  To filter by Queues, enter the queue ID/ARN, not the name of the queue.
    ///   - groupings: The grouping applied to the metrics returned. For example, when results are grouped by queue, the metrics returned are grouped by queue. The values returned apply to the metrics for each queue rather than aggregated for all queues. If no grouping is specified, a summary of metrics for all queues is returned. RoutingStepExpression is not a valid filter for GetMetricData and we recommend switching to GetMetricDataV2 for more up-to-date features.
    ///   - historicalMetrics: The metrics to retrieve. Specify the name, unit, and statistic for each metric. The following historical metrics are available. For a description of each metric, see Metrics definition in the Amazon Connect Administrator Guide.  This API does not support a contacts incoming metric (there's no CONTACTS_INCOMING metric missing from the documented list).    ABANDON_TIME  Unit: SECONDS Statistic: AVG  AFTER_CONTACT_WORK_TIME  Unit: SECONDS Statistic: AVG  API_CONTACTS_HANDLED  Unit: COUNT Statistic: SUM  CALLBACK_CONTACTS_HANDLED  Unit: COUNT Statistic: SUM  CONTACTS_ABANDONED  Unit: COUNT Statistic: SUM  CONTACTS_AGENT_HUNG_UP_FIRST  Unit: COUNT Statistic: SUM  CONTACTS_CONSULTED  Unit: COUNT Statistic: SUM  CONTACTS_HANDLED  Unit: COUNT Statistic: SUM  CONTACTS_HANDLED_INCOMING  Unit: COUNT Statistic: SUM  CONTACTS_HANDLED_OUTBOUND  Unit: COUNT Statistic: SUM  CONTACTS_HOLD_ABANDONS  Unit: COUNT Statistic: SUM  CONTACTS_MISSED  Unit: COUNT Statistic: SUM  CONTACTS_QUEUED  Unit: COUNT Statistic: SUM  CONTACTS_TRANSFERRED_IN  Unit: COUNT Statistic: SUM  CONTACTS_TRANSFERRED_IN_FROM_QUEUE  Unit: COUNT Statistic: SUM  CONTACTS_TRANSFERRED_OUT  Unit: COUNT Statistic: SUM  CONTACTS_TRANSFERRED_OUT_FROM_QUEUE  Unit: COUNT Statistic: SUM  HANDLE_TIME  Unit: SECONDS Statistic: AVG  HOLD_TIME  Unit: SECONDS Statistic: AVG  INTERACTION_AND_HOLD_TIME  Unit: SECONDS Statistic: AVG  INTERACTION_TIME  Unit: SECONDS Statistic: AVG  OCCUPANCY  Unit: PERCENT Statistic: AVG  QUEUE_ANSWER_TIME  Unit: SECONDS Statistic: AVG  QUEUED_TIME  Unit: SECONDS Statistic: MAX  SERVICE_LEVEL  You can include up to 20 SERVICE_LEVEL metrics in a request. Unit: PERCENT Statistic: AVG Threshold: For ThresholdValue, enter any whole number from 1 to 604800 (inclusive), in seconds. For Comparison, you must enter LT (for "Less than").
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - startTime: The timestamp, in UNIX Epoch time format, at which to start the reporting interval for the retrieval of historical metrics data. The time must be specified using a multiple of 5 minutes, such as 10:05, 10:10, 10:15. The start time cannot be earlier than 24 hours before the time of the request. Historical metrics are available only for 24 hours.
    ///   - logger: Logger use during operation
    @inlinable
    public func getMetricData(
        endTime: Date,
        filters: Filters,
        groupings: [Grouping]? = nil,
        historicalMetrics: [HistoricalMetric],
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        startTime: Date,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMetricDataResponse {
        let input = GetMetricDataRequest(
            endTime: endTime, 
            filters: filters, 
            groupings: groupings, 
            historicalMetrics: historicalMetrics, 
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            startTime: startTime
        )
        return try await self.getMetricData(input, logger: logger)
    }

    /// Gets metric data from the specified Amazon Connect instance.   GetMetricDataV2 offers more features than GetMetricData, the previous version of this API. It has new metrics, offers filtering at a metric level, and offers the ability to filter and group data by channels, queues, routing profiles, agents, and agent hierarchy levels. It can retrieve historical data for the last 3 months, at varying intervals. It does not support agent queues. For a description of the historical metrics that are supported by GetMetricDataV2 and GetMetricData, see Metrics definitions in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func getMetricDataV2(_ input: GetMetricDataV2Request, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMetricDataV2Response {
        try await self.client.execute(
            operation: "GetMetricDataV2", 
            path: "/metrics/data", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets metric data from the specified Amazon Connect instance.   GetMetricDataV2 offers more features than GetMetricData, the previous version of this API. It has new metrics, offers filtering at a metric level, and offers the ability to filter and group data by channels, queues, routing profiles, agents, and agent hierarchy levels. It can retrieve historical data for the last 3 months, at varying intervals. It does not support agent queues. For a description of the historical metrics that are supported by GetMetricDataV2 and GetMetricData, see Metrics definitions in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - endTime: The timestamp, in UNIX Epoch time format, at which to end the reporting interval for the retrieval of historical metrics data. The time must be later than the start time timestamp. It cannot be later than the current timestamp.
    ///   - filters: The filters to apply to returned metrics. You can filter on the following resources:   Agents   Campaigns   Channels   Feature   Queues   Routing profiles   Routing step expression   User hierarchy groups   At least one filter must be passed from queues, routing profiles, agents, or user hierarchy groups. For metrics for outbound campaigns analytics, you can also use campaigns to satisfy at least one filter requirement. To filter by phone number, see Create a historical metrics report in the Amazon Connect Administrator Guide. Note the following limits:    Filter keys: A maximum of 5 filter keys are supported in a single request. Valid filter keys: AGENT | AGENT_HIERARCHY_LEVEL_ONE | AGENT_HIERARCHY_LEVEL_TWO | AGENT_HIERARCHY_LEVEL_THREE | AGENT_HIERARCHY_LEVEL_FOUR | AGENT_HIERARCHY_LEVEL_FIVE | ANSWERING_MACHINE_DETECTION_STATUS | BOT_ID | BOT_ALIAS | BOT_VERSION | BOT_LOCALE | BOT_INTENT_NAME | CAMPAIGN | CAMPAIGN_DELIVERY_EVENT_TYPE | CAMPAIGN_EXCLUDED_EVENT_TYPE  | CASE_TEMPLATE_ARN | CASE_STATUS | CHANNEL | contact/segmentAttributes/connect:Subtype | DISCONNECT_REASON | EVALUATION_FORM | EVALUATION_SECTION | EVALUATION_QUESTION | EVALUATION_SOURCE | FEATURE | FLOW_ACTION_ID | FLOW_TYPE | FLOWS_MODULE_RESOURCE_ID | FLOWS_NEXT_RESOURCE_ID | FLOWS_NEXT_RESOURCE_QUEUE_ID | FLOWS_OUTCOME_TYPE | FLOWS_RESOURCE_ID | FORM_VERSION | INITIATION_METHOD | INVOKING_RESOURCE_PUBLISHED_TIMESTAMP | INVOKING_RESOURCE_TYPE | PARENT_FLOWS_RESOURCE_ID | RESOURCE_PUBLISHED_TIMESTAMP | ROUTING_PROFILE | ROUTING_STEP_EXPRESSION | QUEUE | Q_CONNECT_ENABLED |     Filter values: A maximum of 100 filter values are supported in a single request. VOICE, CHAT, and TASK are valid filterValue for the CHANNEL filter key. They do not count towards limitation of 100 filter values. For example, a GetMetricDataV2 request can filter by 50 queues, 35 agents, and 15 routing profiles for a total of 100 filter values, along with 3 channel filters.   contact_lens_conversational_analytics is a valid filterValue for the FEATURE filter key. It is available only to contacts analyzed by Contact Lens conversational analytics.  connect:Chat, connect:SMS, connect:Telephony, and connect:WebRTC are valid filterValue examples (not exhaustive) for the contact/segmentAttributes/connect:Subtype filter key.  ROUTING_STEP_EXPRESSION is a valid filter key with a filter value up to 3000 length. This filter is case and order sensitive. JSON string fields must be sorted in ascending order and JSON array order should be kept as is.  Q_CONNECT_ENABLED. TRUE and FALSE are the only valid filterValues for the Q_CONNECT_ENABLED filter key.    TRUE includes all contacts that had Amazon Q in Connect enabled as part of the flow.   FALSE includes all contacts that did not have Amazon Q in Connect enabled as part of the flow   This filter is available only for contact record-driven metrics.   Campaign ARNs are valid filterValues for the CAMPAIGN filter key.
    ///   - groupings: The grouping applied to the metrics that are returned. For example, when results are grouped by queue, the metrics returned are grouped by queue. The values that are returned apply to the metrics for each queue. They are not aggregated for all queues. If no grouping is specified, a summary of all metrics is returned. Valid grouping keys: AGENT | AGENT_HIERARCHY_LEVEL_ONE | AGENT_HIERARCHY_LEVEL_TWO | AGENT_HIERARCHY_LEVEL_THREE | AGENT_HIERARCHY_LEVEL_FOUR | AGENT_HIERARCHY_LEVEL_FIVE | ANSWERING_MACHINE_DETECTION_STATUS | BOT_ID | BOT_ALIAS | BOT_VERSION | BOT_LOCALE | BOT_INTENT_NAME | CAMPAIGN | CAMPAIGN_DELIVERY_EVENT_TYPE | CAMPAIGN_EXCLUDED_EVENT_TYPE | CAMPAIGN_EXECUTION_TIMESTAMP | CASE_TEMPLATE_ARN | CASE_STATUS | CHANNEL | contact/segmentAttributes/connect:Subtype | DISCONNECT_REASON | EVALUATION_FORM | EVALUATION_SECTION | EVALUATION_QUESTION | EVALUATION_SOURCE | FLOWS_RESOURCE_ID | FLOWS_MODULE_RESOURCE_ID | FLOW_ACTION_ID | FLOW_TYPE | FLOWS_OUTCOME_TYPE | FORM_VERSION | INITIATION_METHOD | INVOKING_RESOURCE_PUBLISHED_TIMESTAMP | INVOKING_RESOURCE_TYPE | PARENT_FLOWS_RESOURCE_ID | Q_CONNECT_ENABLED | QUEUE | RESOURCE_PUBLISHED_TIMESTAMP | ROUTING_PROFILE | ROUTING_STEP_EXPRESSION  Type: Array of strings Array Members: Maximum number of 4 items Required: No
    ///   - interval: The interval period and timezone to apply to returned metrics.    IntervalPeriod: An aggregated grouping applied to request metrics. Valid IntervalPeriod values are: FIFTEEN_MIN | THIRTY_MIN | HOUR | DAY | WEEK | TOTAL.  For example, if IntervalPeriod is selected THIRTY_MIN, StartTime and EndTime differs by 1 day, then Amazon Connect returns 48 results in the response. Each result is aggregated by the THIRTY_MIN period. By default Amazon Connect aggregates results based on the TOTAL interval period.  The following list describes restrictions on StartTime and EndTime based on which IntervalPeriod is requested.     FIFTEEN_MIN: The difference between StartTime and EndTime must be less than 3 days.    THIRTY_MIN: The difference between StartTime and EndTime must be less than 3 days.    HOUR: The difference between StartTime and EndTime must be less than 3 days.    DAY: The difference between StartTime and EndTime must be less than 35 days.    WEEK: The difference between StartTime and EndTime must be less than 35 days.    TOTAL: The difference between StartTime and EndTime must be less than 35 days.      TimeZone: The timezone applied to requested metrics.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - metrics: The metrics to retrieve. Specify the name, groupings, and filters for each metric. The following historical metrics are available. For a description of each metric, see Metrics definition in the Amazon Connect Administrator Guide.  ABANDONMENT_RATE  Unit: Percent Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Abandonment rate   AGENT_ADHERENT_TIME  This metric is available only in Amazon Web Services Regions where Forecasting, capacity planning, and scheduling is available. Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy  UI name: Adherent time   AGENT_ANSWER_RATE  Unit: Percent Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy UI name: Agent answer rate   AGENT_NON_ADHERENT_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy UI name: Non-adherent time   AGENT_NON_RESPONSE  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy  UI name: Agent non-response   AGENT_NON_RESPONSE_WITHOUT_CUSTOMER_ABANDONS  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy Data for this metric is available starting from October 1, 2023 0:00:00 GMT. UI name: Agent non-response without customer abandons   AGENT_OCCUPANCY  Unit: Percentage Valid groupings and filters: Routing Profile, Agent, Agent Hierarchy  UI name: Occupancy   AGENT_SCHEDULE_ADHERENCE  This metric is available only in Amazon Web Services Regions where Forecasting, capacity planning, and scheduling is available. Unit: Percent Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy UI name: Adherence   AGENT_SCHEDULED_TIME  This metric is available only in Amazon Web Services Regions where Forecasting, capacity planning, and scheduling is available. Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy UI name: Scheduled time   AVG_ABANDON_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average queue abandon time   AVG_ACTIVE_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Average active time   AVG_AFTER_CONTACT_WORK_TIME  Unit: Seconds Valid metric filter key: INITIATION_METHOD  Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average after contact work time   Feature is a valid filter but not a valid grouping.   AVG_AGENT_CONNECTING_TIME  Unit: Seconds Valid metric filter key: INITIATION_METHOD. For now, this metric only supports the following as INITIATION_METHOD: INBOUND | OUTBOUND | CALLBACK | API  Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy UI name: Average agent API connecting time   The Negate key in metric-level filters is not applicable for this metric.   AVG_AGENT_PAUSE_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Average agent pause time   AVG_BOT_CONVERSATION_TIME  Unit: Seconds Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Bot ID, Bot alias, Bot version, Bot locale, Flows resource ID, Flows module resource ID, Flow type, Flow action ID, Invoking resource published timestamp, Initiation method, Invoking resource type, Parent flows resource ID UI name: Average bot conversation time   AVG_BOT_CONVERSATION_TURNS  Unit: Count Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Bot ID, Bot alias, Bot version, Bot locale, Flows resource ID, Flows module resource ID, Flow type, Flow action ID, Invoking resource published timestamp, Initiation method, Invoking resource type, Parent flows resource ID UI name: Average bot conversation turns   AVG_CASE_RELATED_CONTACTS  Unit: Count Required filter key: CASE_TEMPLATE_ARN Valid groupings and filters: CASE_TEMPLATE_ARN, CASE_STATUS UI name: Average contacts per case   AVG_CASE_RESOLUTION_TIME  Unit: Seconds Required filter key: CASE_TEMPLATE_ARN Valid groupings and filters: CASE_TEMPLATE_ARN, CASE_STATUS UI name: Average case resolution time   AVG_CONTACT_DURATION  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average contact duration   Feature is a valid filter but not a valid grouping.   AVG_CONVERSATION_DURATION  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average conversation duration   AVG_DIALS_PER_MINUTE  This metric is available only for outbound campaigns that use the agent assisted voice and automated voice delivery modes. Unit: Count Valid groupings and filters: Agent, Campaign, Queue, Routing Profile UI name: Average dials per minute   AVG_EVALUATION_SCORE  Unit: Percent Valid groupings and filters: Agent, Agent Hierarchy, Channel, Evaluation Form ID, Evaluation Section ID, Evaluation Question ID, Evaluation Source, Form Version, Queue, Routing Profile UI name: Average evaluation score   AVG_FLOW_TIME  Unit: Seconds Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Flow type, Flows module resource ID, Flows next resource ID, Flows next resource queue ID, Flows outcome type, Flows resource ID, Initiation method, Resource published timestamp UI name: Average flow time   AVG_GREETING_TIME_AGENT  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average agent greeting time   AVG_HANDLE_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, RoutingStepExpression UI name: Average handle time   Feature is a valid filter but not a valid grouping.   AVG_HOLD_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average customer hold time   Feature is a valid filter but not a valid grouping.   AVG_HOLD_TIME_ALL_CONTACTS  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average customer hold time all contacts   AVG_HOLDS  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average holds   Feature is a valid filter but not a valid grouping.   AVG_INTERACTION_AND_HOLD_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average agent interaction and customer hold time   AVG_INTERACTION_TIME  Unit: Seconds Valid metric filter key: INITIATION_METHOD  Valid groupings and filters: Queue, Channel, Routing Profile, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average agent interaction time   Feature is a valid filter but not a valid grouping.   AVG_INTERRUPTIONS_AGENT  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average agent interruptions   AVG_INTERRUPTION_TIME_AGENT  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average agent interruption time   AVG_NON_TALK_TIME  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average non-talk time   AVG_QUEUE_ANSWER_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average queue answer time   Feature is a valid filter but not a valid grouping.   AVG_RESOLUTION_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average resolution time   AVG_TALK_TIME  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average talk time   AVG_TALK_TIME_AGENT  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average agent talk time   AVG_TALK_TIME_CUSTOMER  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average customer talk time   AVG_WAIT_TIME_AFTER_CUSTOMER_CONNECTION  This metric is available only for outbound campaigns that use the agent assisted voice and automated voice delivery modes. Unit: Seconds Valid groupings and filters: Campaign UI name: Average wait time after customer connection   AVG_WEIGHTED_EVALUATION_SCORE  Unit: Percent Valid groupings and filters: Agent, Agent Hierarchy, Channel, Evaluation Form Id, Evaluation Section ID, Evaluation Question ID, Evaluation Source, Form Version, Queue, Routing Profile UI name: Average weighted evaluation score   BOT_CONVERSATIONS_COMPLETED  Unit: Count Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Bot ID, Bot alias, Bot version, Bot locale, Flows resource ID, Flows module resource ID, Flow type, Flow action ID, Invoking resource published timestamp, Initiation method, Invoking resource type, Parent flows resource ID UI name: Bot conversations completed   BOT_INTENTS_COMPLETED  Unit: Count Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Bot ID, Bot alias, Bot version, Bot locale, Bot intent name, Flows resource ID, Flows module resource ID, Flow type, Flow action ID, Invoking resource published timestamp, Initiation method, Invoking resource type, Parent flows resource ID UI name: Bot intents completed   CAMPAIGN_CONTACTS_ABANDONED_AFTER_X  This metric is available only for outbound campaigns using the agent assisted voice and automated voice delivery modes. Unit: Count Valid groupings and filters: Agent, Campaign Threshold: For ThresholdValue, enter any whole number from 1 to 604800 (inclusive), in seconds. For Comparison, you must enter GT (for Greater than). UI name: Campaign contacts abandoned after X   CAMPAIGN_CONTACTS_ABANDONED_AFTER_X_RATE  This metric is available only for outbound campaigns using the agent assisted voice and automated voice delivery modes. Unit: Percent Valid groupings and filters: Agent, Campaign Threshold: For ThresholdValue, enter any whole number from 1 to 604800 (inclusive), in seconds. For Comparison, you must enter GT (for Greater than). UI name: Campaign contacts abandoned after X rate   CAMPAIGN_INTERACTIONS  This metric is available only for outbound campaigns using the email delivery mode.  Unit: Count Valid metric filter key: CAMPAIGN_INTERACTION_EVENT_TYPE Valid groupings and filters: Campaign UI name: Campaign interactions   CAMPAIGN_PROGRESS_RATE  This metric is only available for outbound campaigns initiated using a customer segment. It is not available for event triggered campaigns. Unit: Percent Valid groupings and filters: Campaign, Campaign Execution Timestamp UI name: Campaign progress rate   CAMPAIGN_SEND_ATTEMPTS  This metric is available only for outbound campaigns. Unit: Count Valid groupings and filters: Campaign, Channel, contact/segmentAttributes/connect:Subtype  UI name: Campaign send attempts   CAMPAIGN_SEND_EXCLUSIONS  This metric is available only for outbound campaigns. Valid metric filter key: CAMPAIGN_EXCLUDED_EVENT_TYPE Unit: Count Valid groupings and filters: Campaign, Campaign Excluded Event Type, Campaign Execution Timestamp UI name: Campaign send exclusions   CASES_CREATED  Unit: Count Required filter key: CASE_TEMPLATE_ARN Valid groupings and filters: CASE_TEMPLATE_ARN, CASE_STATUS UI name: Cases created   CONTACTS_CREATED  Unit: Count Valid metric filter key: INITIATION_METHOD  Valid groupings and filters: Queue, Channel, Routing Profile, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Contacts created   Feature is a valid filter but not a valid grouping.   CONTACTS_HANDLED  Unit: Count Valid metric filter key: INITIATION_METHOD, DISCONNECT_REASON  Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, RoutingStepExpression, Q in Connect UI name: API contacts handled   Feature is a valid filter but not a valid grouping.   CONTACTS_HANDLED_BY_CONNECTED_TO_AGENT  Unit: Count Valid metric filter key: INITIATION_METHOD  Valid groupings and filters: Queue, Channel, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Contacts handled (connected to agent timestamp)   CONTACTS_HOLD_ABANDONS  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Contacts hold disconnect   CONTACTS_ON_HOLD_AGENT_DISCONNECT  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Contacts hold agent disconnect   CONTACTS_ON_HOLD_CUSTOMER_DISCONNECT  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Contacts hold customer disconnect   CONTACTS_PUT_ON_HOLD  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Contacts put on hold   CONTACTS_TRANSFERRED_OUT_EXTERNAL  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Contacts transferred out external   CONTACTS_TRANSFERRED_OUT_INTERNAL  Unit: Percent Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Contacts transferred out internal   CONTACTS_QUEUED  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Contacts queued   CONTACTS_QUEUED_BY_ENQUEUE  Unit: Count Valid groupings and filters: Queue, Channel, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype UI name: Contacts queued (enqueue timestamp)   CONTACTS_REMOVED_FROM_QUEUE_IN_X  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Q in Connect Threshold: For ThresholdValue, enter any whole number from 1 to 604800 (inclusive), in seconds. For Comparison, you can use LT (for "Less than") or LTE (for "Less than equal"). UI name: Contacts removed from queue in X seconds   CONTACTS_RESOLVED_IN_X  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, contact/segmentAttributes/connect:Subtype, Q in Connect Threshold: For ThresholdValue, enter any whole number from 1 to 604800 (inclusive), in seconds. For Comparison, you can use LT (for "Less than") or LTE (for "Less than equal"). UI name: Contacts resolved in X   CONTACTS_TRANSFERRED_OUT  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Contacts transferred out   Feature is a valid filter but not a valid grouping.   CONTACTS_TRANSFERRED_OUT_BY_AGENT  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Contacts transferred out by agent   CONTACTS_TRANSFERRED_OUT_FROM_QUEUE  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Contacts transferred out queue   CURRENT_CASES  Unit: Count Required filter key: CASE_TEMPLATE_ARN Valid groupings and filters: CASE_TEMPLATE_ARN, CASE_STATUS UI name: Current cases   DELIVERY_ATTEMPTS  This metric is available only for outbound campaigns. Unit: Count Valid metric filter key: ANSWERING_MACHINE_DETECTION_STATUS, CAMPAIGN_DELIVERY_EVENT_TYPE, DISCONNECT_REASON  Valid groupings and filters: Agent, Answering Machine Detection Status, Campaign, Campaign Delivery EventType, Channel, contact/segmentAttributes/connect:Subtype, Disconnect Reason, Queue, Routing Profile UI name: Delivery attempts   Campaign Delivery EventType filter and grouping are only available for SMS and Email campaign delivery modes. Agent, Queue, Routing Profile, Answering Machine Detection Status and Disconnect Reason are only available for agent assisted voice and automated voice delivery modes.    DELIVERY_ATTEMPT_DISPOSITION_RATE  This metric is available only for outbound campaigns. Dispositions for the agent assisted voice and automated voice delivery modes are only available with answering machine detection enabled. Unit: Percent Valid metric filter key: ANSWERING_MACHINE_DETECTION_STATUS, CAMPAIGN_DELIVERY_EVENT_TYPE, DISCONNECT_REASON  Valid groupings and filters: Agent, Answering Machine Detection Status, Campaign, Channel, contact/segmentAttributes/connect:Subtype, Disconnect Reason, Queue, Routing Profile UI name: Delivery attempt disposition rate   Campaign Delivery Event Type filter and grouping are only available for SMS and Email campaign delivery modes. Agent, Queue, Routing Profile, Answering Machine Detection Status and Disconnect Reason are only available for agent assisted voice and automated voice delivery modes.    EVALUATIONS_PERFORMED  Unit: Count Valid groupings and filters: Agent, Agent Hierarchy, Channel, Evaluation Form ID, Evaluation Source, Form Version, Queue, Routing Profile UI name: Evaluations performed   FLOWS_OUTCOME  Unit: Count Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Flow type, Flows module resource ID, Flows next resource ID, Flows next resource queue ID, Flows outcome type, Flows resource ID, Initiation method, Resource published timestamp UI name: Flows outcome   FLOWS_STARTED  Unit: Count Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Flow type, Flows module resource ID, Flows resource ID, Initiation method, Resource published timestamp UI name: Flows started   HUMAN_ANSWERED_CALLS  This metric is available only for outbound campaigns. Dispositions for the agent assisted voice and automated voice delivery modes are only available with answering machine detection enabled.  Unit: Count Valid groupings and filters: Agent, Campaign UI name: Human answered   MAX_FLOW_TIME  Unit: Seconds Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Flow type, Flows module resource ID, Flows next resource ID, Flows next resource queue ID, Flows outcome type, Flows resource ID, Initiation method, Resource published timestamp UI name: Maximum flow time   MAX_QUEUED_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Maximum queued time   MIN_FLOW_TIME  Unit: Seconds Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Flow type, Flows module resource ID, Flows next resource ID, Flows next resource queue ID, Flows outcome type, Flows resource ID, Initiation method, Resource published timestamp UI name: Minimum flow time   PERCENT_AUTOMATIC_FAILS  Unit: Percent Valid groupings and filters: Agent, Agent Hierarchy, Channel, Evaluation Form ID, Evaluation Source, Form Version, Queue, Routing Profile UI name: Automatic fails percent   PERCENT_BOT_CONVERSATIONS_OUTCOME  Unit: Percent Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Bot ID, Bot alias, Bot version, Bot locale, Flows resource ID, Flows module resource ID, Flow type, Flow action ID, Invoking resource published timestamp, Initiation method, Invoking resource type, Parent flows resource ID UI name: Percent bot conversations outcome   PERCENT_BOT_INTENTS_OUTCOME  Unit: Percent Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Bot ID, Bot alias, Bot version, Bot locale, Bot intent name, Flows resource ID, Flows module resource ID, Flow type, Flow action ID, Invoking resource published timestamp, Initiation method, Invoking resource type, Parent flows resource ID UI name: Percent bot intents outcome   PERCENT_CASES_FIRST_CONTACT_RESOLVED  Unit: Percent Required filter key: CASE_TEMPLATE_ARN Valid groupings and filters: CASE_TEMPLATE_ARN, CASE_STATUS UI name: Cases resolved on first contact   PERCENT_CONTACTS_STEP_EXPIRED  Unit: Percent Valid groupings and filters: Queue, RoutingStepExpression UI name: This metric is available in Real-time Metrics UI but not on the Historical Metrics UI.  PERCENT_CONTACTS_STEP_JOINED  Unit: Percent Valid groupings and filters: Queue, RoutingStepExpression UI name: This metric is available in Real-time Metrics UI but not on the Historical Metrics UI.  PERCENT_FLOWS_OUTCOME  Unit: Percent Valid metric filter key: FLOWS_OUTCOME_TYPE  Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Flow type, Flows module resource ID, Flows next resource ID, Flows next resource queue ID, Flows outcome type, Flows resource ID, Initiation method, Resource published timestamp UI name: Flows outcome percentage.  The FLOWS_OUTCOME_TYPE is not a valid grouping.   PERCENT_NON_TALK_TIME  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Percentage Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Non-talk time percent   PERCENT_TALK_TIME  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Percentage Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Talk time percent   PERCENT_TALK_TIME_AGENT  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Percentage Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Agent talk time percent   PERCENT_TALK_TIME_CUSTOMER  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Percentage Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Customer talk time percent   RECIPIENTS_ATTEMPTED  This metric is only available for outbound campaigns initiated using a customer segment. It is not available for event triggered campaigns. Unit: Count Valid groupings and filters: Campaign, Campaign Execution Timestamp UI name: Recipients attempted   RECIPIENTS_INTERACTED  This metric is only available for outbound campaigns initiated using a customer segment. It is not available for event triggered campaigns. Valid metric filter key: CAMPAIGN_INTERACTION_EVENT_TYPE Unit: Count Valid groupings and filters: Campaign, Channel, contact/segmentAttributes/connect:Subtype, Campaign Execution Timestamp UI name: Recipients interacted   RECIPIENTS_TARGETED  This metric is only available for outbound campaigns initiated using a customer segment. It is not available for event triggered campaigns. Unit: Count Valid groupings and filters: Campaign, Campaign Execution Timestamp UI name: Recipients targeted   REOPENED_CASE_ACTIONS  Unit: Count Required filter key: CASE_TEMPLATE_ARN Valid groupings and filters: CASE_TEMPLATE_ARN, CASE_STATUS UI name: Cases reopened   RESOLVED_CASE_ACTIONS  Unit: Count Required filter key: CASE_TEMPLATE_ARN Valid groupings and filters: CASE_TEMPLATE_ARN, CASE_STATUS UI name: Cases resolved   SERVICE_LEVEL  You can include up to 20 SERVICE_LEVEL metrics in a request. Unit: Percent Valid groupings and filters: Queue, Channel, Routing Profile, Q in Connect Threshold: For ThresholdValue, enter any whole number from 1 to 604800 (inclusive), in seconds. For Comparison, you can use LT (for "Less than") or LTE (for "Less than equal"). UI name: Service level X   STEP_CONTACTS_QUEUED  Unit: Count Valid groupings and filters: Queue, RoutingStepExpression UI name: This metric is available in Real-time Metrics UI but not on the Historical Metrics UI.  SUM_AFTER_CONTACT_WORK_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: After contact work time   SUM_CONNECTING_TIME_AGENT  Unit: Seconds Valid metric filter key: INITIATION_METHOD. This metric only supports the following filter keys as INITIATION_METHOD: INBOUND | OUTBOUND | CALLBACK | API  Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy UI name: Agent API connecting time   The Negate key in metric-level filters is not applicable for this metric.   CONTACTS_ABANDONED  Unit: Count Metric filter:    Valid values: API| Incoming | Outbound | Transfer | Callback | Queue_Transfer| Disconnect    Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, RoutingStepExpression, Q in Connect UI name: Contact abandoned   SUM_CONTACTS_ABANDONED_IN_X  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, contact/segmentAttributes/connect:Subtype, Q in Connect Threshold: For ThresholdValue, enter any whole number from 1 to 604800 (inclusive), in seconds. For Comparison, you can use LT (for "Less than") or LTE (for "Less than equal"). UI name: Contacts abandoned in X seconds   SUM_CONTACTS_ANSWERED_IN_X  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, contact/segmentAttributes/connect:Subtype, Q in Connect Threshold: For ThresholdValue, enter any whole number from 1 to 604800 (inclusive), in seconds. For Comparison, you can use LT (for "Less than") or LTE (for "Less than equal"). UI name: Contacts answered in X seconds   SUM_CONTACT_FLOW_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Contact flow time   SUM_CONTACT_TIME_AGENT  Unit: Seconds Valid groupings and filters: Routing Profile, Agent, Agent Hierarchy UI name: Agent on contact time   SUM_CONTACTS_DISCONNECTED   Valid metric filter key: DISCONNECT_REASON  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Contact disconnected   SUM_ERROR_STATUS_TIME_AGENT  Unit: Seconds Valid groupings and filters: Routing Profile, Agent, Agent Hierarchy UI name: Error status time   SUM_HANDLE_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Contact handle time   SUM_HOLD_TIME  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Customer hold time   SUM_IDLE_TIME_AGENT  Unit: Seconds Valid groupings and filters: Routing Profile, Agent, Agent Hierarchy UI name: Agent idle time   SUM_INTERACTION_AND_HOLD_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Agent interaction and hold time   SUM_INTERACTION_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy UI name: Agent interaction time   SUM_NON_PRODUCTIVE_TIME_AGENT  Unit: Seconds Valid groupings and filters: Routing Profile, Agent, Agent Hierarchy UI name: Agent non-productive time   SUM_ONLINE_TIME_AGENT  Unit: Seconds Valid groupings and filters: Routing Profile, Agent, Agent Hierarchy UI name: Online time   SUM_RETRY_CALLBACK_ATTEMPTS  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Callback attempts
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource. This includes the instanceId an Amazon Connect instance.
    ///   - startTime: The timestamp, in UNIX Epoch time format, at which to start the reporting interval for the retrieval of historical metrics data. The time must be before the end time timestamp. The start and end time depends on the IntervalPeriod selected. By default the time range between start and end time is 35 days. Historical metrics are available for 3 months.
    ///   - logger: Logger use during operation
    @inlinable
    public func getMetricDataV2(
        endTime: Date,
        filters: [FilterV2],
        groupings: [String]? = nil,
        interval: IntervalDetails? = nil,
        maxResults: Int? = nil,
        metrics: [MetricV2],
        nextToken: String? = nil,
        resourceArn: String,
        startTime: Date,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMetricDataV2Response {
        let input = GetMetricDataV2Request(
            endTime: endTime, 
            filters: filters, 
            groupings: groupings, 
            interval: interval, 
            maxResults: maxResults, 
            metrics: metrics, 
            nextToken: nextToken, 
            resourceArn: resourceArn, 
            startTime: startTime
        )
        return try await self.getMetricDataV2(input, logger: logger)
    }

    /// Gets the prompt file.
    @Sendable
    @inlinable
    public func getPromptFile(_ input: GetPromptFileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetPromptFileResponse {
        try await self.client.execute(
            operation: "GetPromptFile", 
            path: "/prompts/{InstanceId}/{PromptId}/file", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the prompt file.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - promptId: A unique identifier for the prompt.
    ///   - logger: Logger use during operation
    @inlinable
    public func getPromptFile(
        instanceId: String,
        promptId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetPromptFileResponse {
        let input = GetPromptFileRequest(
            instanceId: instanceId, 
            promptId: promptId
        )
        return try await self.getPromptFile(input, logger: logger)
    }

    /// Gets details about a specific task template in the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func getTaskTemplate(_ input: GetTaskTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTaskTemplateResponse {
        try await self.client.execute(
            operation: "GetTaskTemplate", 
            path: "/instance/{InstanceId}/task/template/{TaskTemplateId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets details about a specific task template in the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - snapshotVersion: The system generated version of a task template that is associated with a task, when the task is created.
    ///   - taskTemplateId: A unique identifier for the task template.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTaskTemplate(
        instanceId: String,
        snapshotVersion: String? = nil,
        taskTemplateId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTaskTemplateResponse {
        let input = GetTaskTemplateRequest(
            instanceId: instanceId, 
            snapshotVersion: snapshotVersion, 
            taskTemplateId: taskTemplateId
        )
        return try await self.getTaskTemplate(input, logger: logger)
    }

    /// Retrieves the current traffic distribution for a given traffic distribution group.
    @Sendable
    @inlinable
    public func getTrafficDistribution(_ input: GetTrafficDistributionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTrafficDistributionResponse {
        try await self.client.execute(
            operation: "GetTrafficDistribution", 
            path: "/traffic-distribution/{Id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the current traffic distribution for a given traffic distribution group.
    ///
    /// Parameters:
    ///   - id: The identifier of the traffic distribution group.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTrafficDistribution(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTrafficDistributionResponse {
        let input = GetTrafficDistributionRequest(
            id: id
        )
        return try await self.getTrafficDistribution(input, logger: logger)
    }

    /// Imports a claimed phone number from an external service, such as Amazon Web Services End User Messaging, into an Amazon Connect instance. You can call this API only in the same Amazon Web Services Region where the Amazon Connect instance was created.  Call the DescribePhoneNumber API to verify the status of a previous ImportPhoneNumber operation.   If you plan to claim or import numbers and then release numbers frequently, contact us for a service quota exception. Otherwise, it is possible you will be blocked from claiming and releasing any more numbers until up to 180 days past the oldest number released has expired.  By default you can claim or import and then release up to 200% of your maximum number of active phone numbers. If you claim or import and then release phone numbers using the UI or API during a rolling 180 day cycle that exceeds 200% of your phone number service level quota, you will be blocked from claiming or importing any more numbers until 180 days past the oldest number released has expired.  For example, if you already have 99 claimed or imported numbers and a service level quota of 99 phone numbers, and in any 180 day period you release 99, claim 99, and then release 99, you will have exceeded the 200% limit. At that point you are blocked from claiming any more numbers until you open an Amazon Web ServicesSupport ticket.
    @Sendable
    @inlinable
    public func importPhoneNumber(_ input: ImportPhoneNumberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ImportPhoneNumberResponse {
        try await self.client.execute(
            operation: "ImportPhoneNumber", 
            path: "/phone-number/import", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Imports a claimed phone number from an external service, such as Amazon Web Services End User Messaging, into an Amazon Connect instance. You can call this API only in the same Amazon Web Services Region where the Amazon Connect instance was created.  Call the DescribePhoneNumber API to verify the status of a previous ImportPhoneNumber operation.   If you plan to claim or import numbers and then release numbers frequently, contact us for a service quota exception. Otherwise, it is possible you will be blocked from claiming and releasing any more numbers until up to 180 days past the oldest number released has expired.  By default you can claim or import and then release up to 200% of your maximum number of active phone numbers. If you claim or import and then release phone numbers using the UI or API during a rolling 180 day cycle that exceeds 200% of your phone number service level quota, you will be blocked from claiming or importing any more numbers until 180 days past the oldest number released has expired.  For example, if you already have 99 claimed or imported numbers and a service level quota of 99 phone numbers, and in any 180 day period you release 99, claim 99, and then release 99, you will have exceeded the 200% limit. At that point you are blocked from claiming any more numbers until you open an Amazon Web ServicesSupport ticket.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - phoneNumberDescription: The description of the phone number.
    ///   - sourcePhoneNumberArn: The claimed phone number ARN being imported from the external service, such as Amazon Web Services End User Messaging. If it is from Amazon Web Services End User Messaging, it looks like the ARN of the phone number to import from Amazon Web Services End User Messaging.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - logger: Logger use during operation
    @inlinable
    public func importPhoneNumber(
        clientToken: String? = ImportPhoneNumberRequest.idempotencyToken(),
        instanceId: String,
        phoneNumberDescription: String? = nil,
        sourcePhoneNumberArn: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ImportPhoneNumberResponse {
        let input = ImportPhoneNumberRequest(
            clientToken: clientToken, 
            instanceId: instanceId, 
            phoneNumberDescription: phoneNumberDescription, 
            sourcePhoneNumberArn: sourcePhoneNumberArn, 
            tags: tags
        )
        return try await self.importPhoneNumber(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Lists agent statuses.
    @Sendable
    @inlinable
    public func listAgentStatuses(_ input: ListAgentStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAgentStatusResponse {
        try await self.client.execute(
            operation: "ListAgentStatuses", 
            path: "/agent-status/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Lists agent statuses.
    ///
    /// Parameters:
    ///   - agentStatusTypes: Available agent status types.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listAgentStatuses(
        agentStatusTypes: [AgentStatusType]? = nil,
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAgentStatusResponse {
        let input = ListAgentStatusRequest(
            agentStatusTypes: agentStatusTypes, 
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAgentStatuses(input, logger: logger)
    }

    /// Lists the association status of requested dataset ID for a given Amazon Connect instance.
    @Sendable
    @inlinable
    public func listAnalyticsDataAssociations(_ input: ListAnalyticsDataAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAnalyticsDataAssociationsResponse {
        try await self.client.execute(
            operation: "ListAnalyticsDataAssociations", 
            path: "/analytics-data/instance/{InstanceId}/association", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the association status of requested dataset ID for a given Amazon Connect instance.
    ///
    /// Parameters:
    ///   - dataSetId: The identifier of the dataset to get the association status.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listAnalyticsDataAssociations(
        dataSetId: String? = nil,
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAnalyticsDataAssociationsResponse {
        let input = ListAnalyticsDataAssociationsRequest(
            dataSetId: dataSetId, 
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAnalyticsDataAssociations(input, logger: logger)
    }

    /// Lists the data lake datasets available to associate with for a given Amazon Connect instance.
    @Sendable
    @inlinable
    public func listAnalyticsDataLakeDataSets(_ input: ListAnalyticsDataLakeDataSetsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAnalyticsDataLakeDataSetsResponse {
        try await self.client.execute(
            operation: "ListAnalyticsDataLakeDataSets", 
            path: "/analytics-data/instance/{InstanceId}/datasets", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the data lake datasets available to associate with for a given Amazon Connect instance.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listAnalyticsDataLakeDataSets(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAnalyticsDataLakeDataSetsResponse {
        let input = ListAnalyticsDataLakeDataSetsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAnalyticsDataLakeDataSets(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Returns a paginated list of all approved origins associated with the instance.
    @Sendable
    @inlinable
    public func listApprovedOrigins(_ input: ListApprovedOriginsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListApprovedOriginsResponse {
        try await self.client.execute(
            operation: "ListApprovedOrigins", 
            path: "/instance/{InstanceId}/approved-origins", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Returns a paginated list of all approved origins associated with the instance.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listApprovedOrigins(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListApprovedOriginsResponse {
        let input = ListApprovedOriginsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listApprovedOrigins(input, logger: logger)
    }

    /// Provides information about contact tree, a list of associated contacts with a unique identifier.
    @Sendable
    @inlinable
    public func listAssociatedContacts(_ input: ListAssociatedContactsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAssociatedContactsResponse {
        try await self.client.execute(
            operation: "ListAssociatedContacts", 
            path: "/contact/associated/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides information about contact tree, a list of associated contacts with a unique identifier.
    ///
    /// Parameters:
    ///   - contactId: The identifier of the contact in this instance of Amazon Connect.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The maximum number of results to return per page. The default MaxResult size is 25. Valid Range: Minimum value of 1. Maximum value of 100.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listAssociatedContacts(
        contactId: String,
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAssociatedContactsResponse {
        let input = ListAssociatedContactsRequest(
            contactId: contactId, 
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAssociatedContacts(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. To
    /// request access to this API, contact Amazon Web ServicesSupport. Provides summary information about the authentication profiles in a specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func listAuthenticationProfiles(_ input: ListAuthenticationProfilesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAuthenticationProfilesResponse {
        try await self.client.execute(
            operation: "ListAuthenticationProfiles", 
            path: "/authentication-profiles-summary/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. To
    /// request access to this API, contact Amazon Web ServicesSupport. Provides summary information about the authentication profiles in a specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listAuthenticationProfiles(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAuthenticationProfilesResponse {
        let input = ListAuthenticationProfilesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAuthenticationProfiles(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. For the specified version of Amazon Lex, returns a paginated list of all the Amazon Lex bots currently associated with the instance. Use this API to return both Amazon Lex V1 and V2 bots.
    @Sendable
    @inlinable
    public func listBots(_ input: ListBotsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListBotsResponse {
        try await self.client.execute(
            operation: "ListBots", 
            path: "/instance/{InstanceId}/bots", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. For the specified version of Amazon Lex, returns a paginated list of all the Amazon Lex bots currently associated with the instance. Use this API to return both Amazon Lex V1 and V2 bots.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - lexVersion: The version of Amazon Lex or Amazon Lex V2.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listBots(
        instanceId: String,
        lexVersion: LexVersion,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListBotsResponse {
        let input = ListBotsRequest(
            instanceId: instanceId, 
            lexVersion: lexVersion, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listBots(input, logger: logger)
    }

    /// Lists contact evaluations in the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func listContactEvaluations(_ input: ListContactEvaluationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListContactEvaluationsResponse {
        try await self.client.execute(
            operation: "ListContactEvaluations", 
            path: "/contact-evaluations/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists contact evaluations in the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - contactId: The identifier of the contact in this instance of Amazon Connect.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listContactEvaluations(
        contactId: String,
        instanceId: String,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListContactEvaluationsResponse {
        let input = ListContactEvaluationsRequest(
            contactId: contactId, 
            instanceId: instanceId, 
            nextToken: nextToken
        )
        return try await self.listContactEvaluations(input, logger: logger)
    }

    /// Provides information about the flow modules for the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func listContactFlowModules(_ input: ListContactFlowModulesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListContactFlowModulesResponse {
        try await self.client.execute(
            operation: "ListContactFlowModules", 
            path: "/contact-flow-modules-summary/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides information about the flow modules for the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - contactFlowModuleState: The state of the flow module.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listContactFlowModules(
        contactFlowModuleState: ContactFlowModuleState? = nil,
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListContactFlowModulesResponse {
        let input = ListContactFlowModulesRequest(
            contactFlowModuleState: contactFlowModuleState, 
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listContactFlowModules(input, logger: logger)
    }

    /// Returns all the available versions for the specified Amazon Connect instance and flow identifier.
    @Sendable
    @inlinable
    public func listContactFlowVersions(_ input: ListContactFlowVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListContactFlowVersionsResponse {
        try await self.client.execute(
            operation: "ListContactFlowVersions", 
            path: "/contact-flows/{InstanceId}/{ContactFlowId}/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns all the available versions for the specified Amazon Connect instance and flow identifier.
    ///
    /// Parameters:
    ///   - contactFlowId: The identifier of the flow.
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listContactFlowVersions(
        contactFlowId: String,
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListContactFlowVersionsResponse {
        let input = ListContactFlowVersionsRequest(
            contactFlowId: contactFlowId, 
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listContactFlowVersions(input, logger: logger)
    }

    /// Provides information about the flows for the specified Amazon Connect instance. You can also create and update flows using the Amazon Connect Flow language. For more information about flows, see Flows in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func listContactFlows(_ input: ListContactFlowsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListContactFlowsResponse {
        try await self.client.execute(
            operation: "ListContactFlows", 
            path: "/contact-flows-summary/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides information about the flows for the specified Amazon Connect instance. You can also create and update flows using the Amazon Connect Flow language. For more information about flows, see Flows in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - contactFlowTypes: The type of flow.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listContactFlows(
        contactFlowTypes: [ContactFlowType]? = nil,
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListContactFlowsResponse {
        let input = ListContactFlowsRequest(
            contactFlowTypes: contactFlowTypes, 
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listContactFlows(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. For the specified referenceTypes, returns a list of references associated with the contact. References are links to documents that are related to a contact, such as emails, attachments, or URLs.
    @Sendable
    @inlinable
    public func listContactReferences(_ input: ListContactReferencesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListContactReferencesResponse {
        try await self.client.execute(
            operation: "ListContactReferences", 
            path: "/contact/references/{InstanceId}/{ContactId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. For the specified referenceTypes, returns a list of references associated with the contact. References are links to documents that are related to a contact, such as emails, attachments, or URLs.
    ///
    /// Parameters:
    ///   - contactId: The identifier of the initial contact.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - referenceTypes: The type of reference.
    ///   - logger: Logger use during operation
    @inlinable
    public func listContactReferences(
        contactId: String,
        instanceId: String,
        nextToken: String? = nil,
        referenceTypes: [ReferenceType],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListContactReferencesResponse {
        let input = ListContactReferencesRequest(
            contactId: contactId, 
            instanceId: instanceId, 
            nextToken: nextToken, 
            referenceTypes: referenceTypes
        )
        return try await self.listContactReferences(input, logger: logger)
    }

    /// Lists the default vocabularies for the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func listDefaultVocabularies(_ input: ListDefaultVocabulariesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDefaultVocabulariesResponse {
        try await self.client.execute(
            operation: "ListDefaultVocabularies", 
            path: "/default-vocabulary-summary/{InstanceId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the default vocabularies for the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - languageCode: The language code of the vocabulary entries. For a list of languages and their corresponding language codes, see
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listDefaultVocabularies(
        instanceId: String,
        languageCode: VocabularyLanguageCode? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDefaultVocabulariesResponse {
        let input = ListDefaultVocabulariesRequest(
            instanceId: instanceId, 
            languageCode: languageCode, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDefaultVocabularies(input, logger: logger)
    }

    /// Lists versions of an evaluation form in the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func listEvaluationFormVersions(_ input: ListEvaluationFormVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListEvaluationFormVersionsResponse {
        try await self.client.execute(
            operation: "ListEvaluationFormVersions", 
            path: "/evaluation-forms/{InstanceId}/{EvaluationFormId}/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists versions of an evaluation form in the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - evaluationFormId: The unique identifier for the evaluation form.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listEvaluationFormVersions(
        evaluationFormId: String,
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListEvaluationFormVersionsResponse {
        let input = ListEvaluationFormVersionsRequest(
            evaluationFormId: evaluationFormId, 
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listEvaluationFormVersions(input, logger: logger)
    }

    /// Lists evaluation forms in the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func listEvaluationForms(_ input: ListEvaluationFormsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListEvaluationFormsResponse {
        try await self.client.execute(
            operation: "ListEvaluationForms", 
            path: "/evaluation-forms/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists evaluation forms in the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listEvaluationForms(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListEvaluationFormsResponse {
        let input = ListEvaluationFormsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listEvaluationForms(input, logger: logger)
    }

    /// List the flow association based on the filters.
    @Sendable
    @inlinable
    public func listFlowAssociations(_ input: ListFlowAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListFlowAssociationsResponse {
        try await self.client.execute(
            operation: "ListFlowAssociations", 
            path: "/flow-associations-summary/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List the flow association based on the filters.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - resourceType: A valid resource type.
    ///   - logger: Logger use during operation
    @inlinable
    public func listFlowAssociations(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resourceType: ListFlowAssociationResourceType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListFlowAssociationsResponse {
        let input = ListFlowAssociationsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            resourceType: resourceType
        )
        return try await self.listFlowAssociations(input, logger: logger)
    }

    /// List the hours of operation overrides.
    @Sendable
    @inlinable
    public func listHoursOfOperationOverrides(_ input: ListHoursOfOperationOverridesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListHoursOfOperationOverridesResponse {
        try await self.client.execute(
            operation: "ListHoursOfOperationOverrides", 
            path: "/hours-of-operations/{InstanceId}/{HoursOfOperationId}/overrides", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List the hours of operation overrides.
    ///
    /// Parameters:
    ///   - hoursOfOperationId: The identifier for the hours of operation
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100. Valid Range: Minimum value of 1. Maximum value of 1000.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listHoursOfOperationOverrides(
        hoursOfOperationId: String,
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListHoursOfOperationOverridesResponse {
        let input = ListHoursOfOperationOverridesRequest(
            hoursOfOperationId: hoursOfOperationId, 
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listHoursOfOperationOverrides(input, logger: logger)
    }

    /// Provides information about the hours of operation for the specified Amazon Connect instance. For more information about hours of operation, see Set the Hours of Operation for a Queue in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func listHoursOfOperations(_ input: ListHoursOfOperationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListHoursOfOperationsResponse {
        try await self.client.execute(
            operation: "ListHoursOfOperations", 
            path: "/hours-of-operations-summary/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides information about the hours of operation for the specified Amazon Connect instance. For more information about hours of operation, see Set the Hours of Operation for a Queue in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listHoursOfOperations(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListHoursOfOperationsResponse {
        let input = ListHoursOfOperationsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listHoursOfOperations(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Returns a paginated list of all attribute types for the given instance.
    @Sendable
    @inlinable
    public func listInstanceAttributes(_ input: ListInstanceAttributesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListInstanceAttributesResponse {
        try await self.client.execute(
            operation: "ListInstanceAttributes", 
            path: "/instance/{InstanceId}/attributes", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Returns a paginated list of all attribute types for the given instance.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listInstanceAttributes(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListInstanceAttributesResponse {
        let input = ListInstanceAttributesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listInstanceAttributes(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Returns a paginated list of storage configs for the identified instance and resource type.
    @Sendable
    @inlinable
    public func listInstanceStorageConfigs(_ input: ListInstanceStorageConfigsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListInstanceStorageConfigsResponse {
        try await self.client.execute(
            operation: "ListInstanceStorageConfigs", 
            path: "/instance/{InstanceId}/storage-configs", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Returns a paginated list of storage configs for the identified instance and resource type.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - resourceType: A valid resource type.
    ///   - logger: Logger use during operation
    @inlinable
    public func listInstanceStorageConfigs(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resourceType: InstanceStorageResourceType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListInstanceStorageConfigsResponse {
        let input = ListInstanceStorageConfigsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            resourceType: resourceType
        )
        return try await self.listInstanceStorageConfigs(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Return a list of instances which are in active state, creation-in-progress state, and failed state. Instances that aren't successfully created (they are in a failed state) are returned only for 24 hours after the CreateInstance API was invoked.
    @Sendable
    @inlinable
    public func listInstances(_ input: ListInstancesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListInstancesResponse {
        try await self.client.execute(
            operation: "ListInstances", 
            path: "/instance", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Return a list of instances which are in active state, creation-in-progress state, and failed state. Instances that aren't successfully created (they are in a failed state) are returned only for 24 hours after the CreateInstance API was invoked.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listInstances(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListInstancesResponse {
        let input = ListInstancesRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listInstances(input, logger: logger)
    }

    /// Provides summary information about the Amazon Web Services resource associations for the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func listIntegrationAssociations(_ input: ListIntegrationAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListIntegrationAssociationsResponse {
        try await self.client.execute(
            operation: "ListIntegrationAssociations", 
            path: "/instance/{InstanceId}/integration-associations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides summary information about the Amazon Web Services resource associations for the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - integrationArn: The Amazon Resource Name (ARN) of the integration.
    ///   - integrationType: The integration type.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listIntegrationAssociations(
        instanceId: String,
        integrationArn: String? = nil,
        integrationType: IntegrationType? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListIntegrationAssociationsResponse {
        let input = ListIntegrationAssociationsRequest(
            instanceId: instanceId, 
            integrationArn: integrationArn, 
            integrationType: integrationType, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listIntegrationAssociations(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Returns a paginated list of all Lambda functions that display in the dropdown options in the relevant flow blocks.
    @Sendable
    @inlinable
    public func listLambdaFunctions(_ input: ListLambdaFunctionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListLambdaFunctionsResponse {
        try await self.client.execute(
            operation: "ListLambdaFunctions", 
            path: "/instance/{InstanceId}/lambda-functions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Returns a paginated list of all Lambda functions that display in the dropdown options in the relevant flow blocks.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listLambdaFunctions(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListLambdaFunctionsResponse {
        let input = ListLambdaFunctionsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listLambdaFunctions(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Returns a paginated list of all the Amazon Lex V1 bots currently associated with the instance. To return both Amazon Lex V1 and V2 bots, use the ListBots API.
    @Sendable
    @inlinable
    public func listLexBots(_ input: ListLexBotsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListLexBotsResponse {
        try await self.client.execute(
            operation: "ListLexBots", 
            path: "/instance/{InstanceId}/lex-bots", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Returns a paginated list of all the Amazon Lex V1 bots currently associated with the instance. To return both Amazon Lex V1 and V2 bots, use the ListBots API.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. If no value is specified, the default is 10.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listLexBots(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListLexBotsResponse {
        let input = ListLexBotsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listLexBots(input, logger: logger)
    }

    /// Provides information about the phone numbers for the specified Amazon Connect instance.  For more information about phone numbers, see Set Up Phone Numbers for Your Contact Center in the Amazon Connect Administrator Guide.    We recommend using ListPhoneNumbersV2 to return phone number types. ListPhoneNumbers doesn't support number types UIFN, SHARED, THIRD_PARTY_TF, and THIRD_PARTY_DID. While it returns numbers of those types, it incorrectly lists them as TOLL_FREE or DID.    The phone number Arn value that is returned from each of the items in the PhoneNumberSummaryList cannot be used to tag phone number resources. It will fail with a ResourceNotFoundException. Instead, use the ListPhoneNumbersV2 API. It returns the new phone number ARN that can be used to tag phone number resources.
    @Sendable
    @inlinable
    public func listPhoneNumbers(_ input: ListPhoneNumbersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPhoneNumbersResponse {
        try await self.client.execute(
            operation: "ListPhoneNumbers", 
            path: "/phone-numbers-summary/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides information about the phone numbers for the specified Amazon Connect instance.  For more information about phone numbers, see Set Up Phone Numbers for Your Contact Center in the Amazon Connect Administrator Guide.    We recommend using ListPhoneNumbersV2 to return phone number types. ListPhoneNumbers doesn't support number types UIFN, SHARED, THIRD_PARTY_TF, and THIRD_PARTY_DID. While it returns numbers of those types, it incorrectly lists them as TOLL_FREE or DID.    The phone number Arn value that is returned from each of the items in the PhoneNumberSummaryList cannot be used to tag phone number resources. It will fail with a ResourceNotFoundException. Instead, use the ListPhoneNumbersV2 API. It returns the new phone number ARN that can be used to tag phone number resources.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - phoneNumberCountryCodes: The ISO country code.
    ///   - phoneNumberTypes: The type of phone number.  We recommend using ListPhoneNumbersV2 to return phone number types. While ListPhoneNumbers returns number types UIFN, SHARED, THIRD_PARTY_TF, and THIRD_PARTY_DID, it incorrectly lists them as TOLL_FREE or DID.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPhoneNumbers(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        phoneNumberCountryCodes: [PhoneNumberCountryCode]? = nil,
        phoneNumberTypes: [PhoneNumberType]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPhoneNumbersResponse {
        let input = ListPhoneNumbersRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            phoneNumberCountryCodes: phoneNumberCountryCodes, 
            phoneNumberTypes: phoneNumberTypes
        )
        return try await self.listPhoneNumbers(input, logger: logger)
    }

    /// Lists phone numbers claimed to your Amazon Connect instance or traffic distribution group. If the provided TargetArn is a traffic distribution group, you can call this API in both Amazon Web Services Regions associated with traffic distribution group. For more information about phone numbers, see Set Up Phone Numbers for Your Contact Center in the Amazon Connect Administrator Guide.    When given an instance ARN, ListPhoneNumbersV2 returns only the phone numbers claimed to the instance.   When given a traffic distribution group ARN ListPhoneNumbersV2 returns only the phone numbers claimed to the traffic distribution group.
    @Sendable
    @inlinable
    public func listPhoneNumbersV2(_ input: ListPhoneNumbersV2Request, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPhoneNumbersV2Response {
        try await self.client.execute(
            operation: "ListPhoneNumbersV2", 
            path: "/phone-number/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists phone numbers claimed to your Amazon Connect instance or traffic distribution group. If the provided TargetArn is a traffic distribution group, you can call this API in both Amazon Web Services Regions associated with traffic distribution group. For more information about phone numbers, see Set Up Phone Numbers for Your Contact Center in the Amazon Connect Administrator Guide.    When given an instance ARN, ListPhoneNumbersV2 returns only the phone numbers claimed to the instance.   When given a traffic distribution group ARN ListPhoneNumbersV2 returns only the phone numbers claimed to the traffic distribution group.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance that phone numbers are claimed to. You can find the instance ID in the Amazon Resource Name (ARN) of the instance. If both TargetArn and InstanceId are not provided, this API lists numbers claimed to all the Amazon Connect instances belonging to your account in the same AWS Region as the request.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - phoneNumberCountryCodes: The ISO country code.
    ///   - phoneNumberPrefix: The prefix of the phone number. If provided, it must contain + as part of the country code.
    ///   - phoneNumberTypes: The type of phone number.
    ///   - targetArn: The Amazon Resource Name (ARN) for Amazon Connect instances or traffic distribution groups that phone number inbound traffic is routed through. If both TargetArn and InstanceId input are not provided, this API lists numbers claimed to all the Amazon Connect instances belonging to your account in the same Amazon Web Services Region as the request.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPhoneNumbersV2(
        instanceId: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        phoneNumberCountryCodes: [PhoneNumberCountryCode]? = nil,
        phoneNumberPrefix: String? = nil,
        phoneNumberTypes: [PhoneNumberType]? = nil,
        targetArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPhoneNumbersV2Response {
        let input = ListPhoneNumbersV2Request(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            phoneNumberCountryCodes: phoneNumberCountryCodes, 
            phoneNumberPrefix: phoneNumberPrefix, 
            phoneNumberTypes: phoneNumberTypes, 
            targetArn: targetArn
        )
        return try await self.listPhoneNumbersV2(input, logger: logger)
    }

    /// Lists predefined attributes for the specified Amazon Connect instance. Predefined attributes are attributes in an Amazon Connect instance that can be used to route contacts to an agent or pools of agents within a queue. For more information, see Create predefined attributes for routing contacts to agents.
    @Sendable
    @inlinable
    public func listPredefinedAttributes(_ input: ListPredefinedAttributesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPredefinedAttributesResponse {
        try await self.client.execute(
            operation: "ListPredefinedAttributes", 
            path: "/predefined-attributes/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists predefined attributes for the specified Amazon Connect instance. Predefined attributes are attributes in an Amazon Connect instance that can be used to route contacts to an agent or pools of agents within a queue. For more information, see Create predefined attributes for routing contacts to agents.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPredefinedAttributes(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPredefinedAttributesResponse {
        let input = ListPredefinedAttributesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listPredefinedAttributes(input, logger: logger)
    }

    /// Provides information about the prompts for the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func listPrompts(_ input: ListPromptsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPromptsResponse {
        try await self.client.execute(
            operation: "ListPrompts", 
            path: "/prompts-summary/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides information about the prompts for the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPrompts(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPromptsResponse {
        let input = ListPromptsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listPrompts(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Lists the quick connects associated with a queue.
    @Sendable
    @inlinable
    public func listQueueQuickConnects(_ input: ListQueueQuickConnectsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListQueueQuickConnectsResponse {
        try await self.client.execute(
            operation: "ListQueueQuickConnects", 
            path: "/queues/{InstanceId}/{QueueId}/quick-connects", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Lists the quick connects associated with a queue.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - queueId: The identifier for the queue.
    ///   - logger: Logger use during operation
    @inlinable
    public func listQueueQuickConnects(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        queueId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListQueueQuickConnectsResponse {
        let input = ListQueueQuickConnectsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            queueId: queueId
        )
        return try await self.listQueueQuickConnects(input, logger: logger)
    }

    /// Provides information about the queues for the specified Amazon Connect instance. If you do not specify a QueueTypes parameter, both standard and agent queues are returned. This might cause an unexpected truncation of results if you have more than 1000 agents and you limit the number of results of the API call in code. For more information about queues, see Queues: Standard and Agent in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func listQueues(_ input: ListQueuesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListQueuesResponse {
        try await self.client.execute(
            operation: "ListQueues", 
            path: "/queues-summary/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides information about the queues for the specified Amazon Connect instance. If you do not specify a QueueTypes parameter, both standard and agent queues are returned. This might cause an unexpected truncation of results if you have more than 1000 agents and you limit the number of results of the API call in code. For more information about queues, see Queues: Standard and Agent in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - queueTypes: The type of queue.
    ///   - logger: Logger use during operation
    @inlinable
    public func listQueues(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        queueTypes: [QueueType]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListQueuesResponse {
        let input = ListQueuesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            queueTypes: queueTypes
        )
        return try await self.listQueues(input, logger: logger)
    }

    /// Provides information about the quick connects for the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func listQuickConnects(_ input: ListQuickConnectsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListQuickConnectsResponse {
        try await self.client.execute(
            operation: "ListQuickConnects", 
            path: "/quick-connects/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides information about the quick connects for the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - quickConnectTypes: The type of quick connect. In the Amazon Connect admin website, when you create a quick connect, you are prompted to assign one of the following types: Agent (USER), External (PHONE_NUMBER), or Queue (QUEUE).
    ///   - logger: Logger use during operation
    @inlinable
    public func listQuickConnects(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        quickConnectTypes: [QuickConnectType]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListQuickConnectsResponse {
        let input = ListQuickConnectsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            quickConnectTypes: quickConnectTypes
        )
        return try await self.listQuickConnects(input, logger: logger)
    }

    /// Provides a list of analysis segments for a real-time chat analysis session. This API supports CHAT channels only.   This API does not support VOICE. If you attempt to use it for VOICE, an InvalidRequestException occurs.
    @Sendable
    @inlinable
    public func listRealtimeContactAnalysisSegmentsV2(_ input: ListRealtimeContactAnalysisSegmentsV2Request, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRealtimeContactAnalysisSegmentsV2Response {
        try await self.client.execute(
            operation: "ListRealtimeContactAnalysisSegmentsV2", 
            path: "/contact/list-real-time-analysis-segments-v2/{InstanceId}/{ContactId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides a list of analysis segments for a real-time chat analysis session. This API supports CHAT channels only.   This API does not support VOICE. If you attempt to use it for VOICE, an InvalidRequestException occurs.
    ///
    /// Parameters:
    ///   - contactId: The identifier of the contact in this instance of Amazon Connect.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - outputType: The Contact Lens output type to be returned.
    ///   - segmentTypes: Enum with segment types . Each value corresponds to a segment type returned in the segments list of the API. Each segment type has its own structure. Different channels may have different sets of supported segment types.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRealtimeContactAnalysisSegmentsV2(
        contactId: String,
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        outputType: RealTimeContactAnalysisOutputType,
        segmentTypes: [RealTimeContactAnalysisSegmentType],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRealtimeContactAnalysisSegmentsV2Response {
        let input = ListRealtimeContactAnalysisSegmentsV2Request(
            contactId: contactId, 
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            outputType: outputType, 
            segmentTypes: segmentTypes
        )
        return try await self.listRealtimeContactAnalysisSegmentsV2(input, logger: logger)
    }

    /// Lists the queues associated with a routing profile.
    @Sendable
    @inlinable
    public func listRoutingProfileQueues(_ input: ListRoutingProfileQueuesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRoutingProfileQueuesResponse {
        try await self.client.execute(
            operation: "ListRoutingProfileQueues", 
            path: "/routing-profiles/{InstanceId}/{RoutingProfileId}/queues", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the queues associated with a routing profile.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - routingProfileId: The identifier of the routing profile.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRoutingProfileQueues(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        routingProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRoutingProfileQueuesResponse {
        let input = ListRoutingProfileQueuesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            routingProfileId: routingProfileId
        )
        return try await self.listRoutingProfileQueues(input, logger: logger)
    }

    /// Provides summary information about the routing profiles for the specified Amazon Connect instance. For more information about routing profiles, see Routing Profiles and Create a Routing Profile in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func listRoutingProfiles(_ input: ListRoutingProfilesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRoutingProfilesResponse {
        try await self.client.execute(
            operation: "ListRoutingProfiles", 
            path: "/routing-profiles-summary/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides summary information about the routing profiles for the specified Amazon Connect instance. For more information about routing profiles, see Routing Profiles and Create a Routing Profile in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listRoutingProfiles(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRoutingProfilesResponse {
        let input = ListRoutingProfilesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listRoutingProfiles(input, logger: logger)
    }

    /// List all rules for the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func listRules(_ input: ListRulesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRulesResponse {
        try await self.client.execute(
            operation: "ListRules", 
            path: "/rules/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List all rules for the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - eventSourceName: The name of the event source.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - publishStatus: The publish status of the rule.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRules(
        eventSourceName: EventSourceName? = nil,
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        publishStatus: RulePublishStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRulesResponse {
        let input = ListRulesRequest(
            eventSourceName: eventSourceName, 
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            publishStatus: publishStatus
        )
        return try await self.listRules(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Returns a paginated list of all security keys associated with the instance.
    @Sendable
    @inlinable
    public func listSecurityKeys(_ input: ListSecurityKeysRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSecurityKeysResponse {
        try await self.client.execute(
            operation: "ListSecurityKeys", 
            path: "/instance/{InstanceId}/security-keys", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Returns a paginated list of all security keys associated with the instance.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listSecurityKeys(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSecurityKeysResponse {
        let input = ListSecurityKeysRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listSecurityKeys(input, logger: logger)
    }

    /// Returns a list of third-party applications in a specific security profile.
    @Sendable
    @inlinable
    public func listSecurityProfileApplications(_ input: ListSecurityProfileApplicationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSecurityProfileApplicationsResponse {
        try await self.client.execute(
            operation: "ListSecurityProfileApplications", 
            path: "/security-profiles-applications/{InstanceId}/{SecurityProfileId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of third-party applications in a specific security profile.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - securityProfileId: The identifier for the security profle.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSecurityProfileApplications(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        securityProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSecurityProfileApplicationsResponse {
        let input = ListSecurityProfileApplicationsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            securityProfileId: securityProfileId
        )
        return try await self.listSecurityProfileApplications(input, logger: logger)
    }

    /// Lists the permissions granted to a security profile. For information about security profiles, see Security Profiles in the Amazon Connect Administrator Guide. For a mapping of the API name and user interface name of the security profile permissions, see List of security profile permissions.
    @Sendable
    @inlinable
    public func listSecurityProfilePermissions(_ input: ListSecurityProfilePermissionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSecurityProfilePermissionsResponse {
        try await self.client.execute(
            operation: "ListSecurityProfilePermissions", 
            path: "/security-profiles-permissions/{InstanceId}/{SecurityProfileId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the permissions granted to a security profile. For information about security profiles, see Security Profiles in the Amazon Connect Administrator Guide. For a mapping of the API name and user interface name of the security profile permissions, see List of security profile permissions.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - securityProfileId: The identifier for the security profle.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSecurityProfilePermissions(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        securityProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSecurityProfilePermissionsResponse {
        let input = ListSecurityProfilePermissionsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            securityProfileId: securityProfileId
        )
        return try await self.listSecurityProfilePermissions(input, logger: logger)
    }

    /// Provides summary information about the security profiles for the specified Amazon Connect instance. For more information about security profiles, see Security Profiles in the Amazon Connect Administrator Guide. For a mapping of the API name and user interface name of the security profile permissions, see List of security profile permissions.
    @Sendable
    @inlinable
    public func listSecurityProfiles(_ input: ListSecurityProfilesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSecurityProfilesResponse {
        try await self.client.execute(
            operation: "ListSecurityProfiles", 
            path: "/security-profiles-summary/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides summary information about the security profiles for the specified Amazon Connect instance. For more information about security profiles, see Security Profiles in the Amazon Connect Administrator Guide. For a mapping of the API name and user interface name of the security profile permissions, see List of security profile permissions.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listSecurityProfiles(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSecurityProfilesResponse {
        let input = ListSecurityProfilesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listSecurityProfiles(input, logger: logger)
    }

    /// Lists the tags for the specified resource. For sample policies that use tags, see Amazon Connect Identity-Based Policy Examples in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the tags for the specified resource. For sample policies that use tags, see Amazon Connect Identity-Based Policy Examples in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource. All Amazon Connect resources (instances, queues, flows, routing profiles, etc) have an ARN. To locate the ARN for an instance, for example, see Find your Amazon Connect instance ID/ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Lists task templates for the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func listTaskTemplates(_ input: ListTaskTemplatesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTaskTemplatesResponse {
        try await self.client.execute(
            operation: "ListTaskTemplates", 
            path: "/instance/{InstanceId}/task/template", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists task templates for the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.  It is not expected that you set this.
    ///   - name: The name of the task template.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - status: Marks a template as ACTIVE or INACTIVE for a task to refer to it.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTaskTemplates(
        instanceId: String,
        maxResults: Int? = nil,
        name: String? = nil,
        nextToken: String? = nil,
        status: TaskTemplateStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTaskTemplatesResponse {
        let input = ListTaskTemplatesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            name: name, 
            nextToken: nextToken, 
            status: status
        )
        return try await self.listTaskTemplates(input, logger: logger)
    }

    /// Lists traffic distribution group users.
    @Sendable
    @inlinable
    public func listTrafficDistributionGroupUsers(_ input: ListTrafficDistributionGroupUsersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTrafficDistributionGroupUsersResponse {
        try await self.client.execute(
            operation: "ListTrafficDistributionGroupUsers", 
            path: "/traffic-distribution-group/{TrafficDistributionGroupId}/user", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists traffic distribution group users.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - trafficDistributionGroupId: The identifier of the traffic distribution group.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTrafficDistributionGroupUsers(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        trafficDistributionGroupId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTrafficDistributionGroupUsersResponse {
        let input = ListTrafficDistributionGroupUsersRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            trafficDistributionGroupId: trafficDistributionGroupId
        )
        return try await self.listTrafficDistributionGroupUsers(input, logger: logger)
    }

    /// Lists traffic distribution groups.
    @Sendable
    @inlinable
    public func listTrafficDistributionGroups(_ input: ListTrafficDistributionGroupsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTrafficDistributionGroupsResponse {
        try await self.client.execute(
            operation: "ListTrafficDistributionGroups", 
            path: "/traffic-distribution-groups", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists traffic distribution groups.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listTrafficDistributionGroups(
        instanceId: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTrafficDistributionGroupsResponse {
        let input = ListTrafficDistributionGroupsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listTrafficDistributionGroups(input, logger: logger)
    }

    /// Lists the use cases for the integration association.
    @Sendable
    @inlinable
    public func listUseCases(_ input: ListUseCasesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListUseCasesResponse {
        try await self.client.execute(
            operation: "ListUseCases", 
            path: "/instance/{InstanceId}/integration-associations/{IntegrationAssociationId}/use-cases", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the use cases for the integration association.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - integrationAssociationId: The identifier for the integration association.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listUseCases(
        instanceId: String,
        integrationAssociationId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListUseCasesResponse {
        let input = ListUseCasesRequest(
            instanceId: instanceId, 
            integrationAssociationId: integrationAssociationId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listUseCases(input, logger: logger)
    }

    /// Provides summary information about the hierarchy groups for the specified Amazon Connect instance. For more information about agent hierarchies, see Set Up Agent Hierarchies in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func listUserHierarchyGroups(_ input: ListUserHierarchyGroupsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListUserHierarchyGroupsResponse {
        try await self.client.execute(
            operation: "ListUserHierarchyGroups", 
            path: "/user-hierarchy-groups-summary/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides summary information about the hierarchy groups for the specified Amazon Connect instance. For more information about agent hierarchies, see Set Up Agent Hierarchies in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listUserHierarchyGroups(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListUserHierarchyGroupsResponse {
        let input = ListUserHierarchyGroupsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listUserHierarchyGroups(input, logger: logger)
    }

    /// Lists proficiencies associated with a user.
    @Sendable
    @inlinable
    public func listUserProficiencies(_ input: ListUserProficienciesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListUserProficienciesResponse {
        try await self.client.execute(
            operation: "ListUserProficiencies", 
            path: "/users/{InstanceId}/{UserId}/proficiencies", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists proficiencies associated with a user.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - userId: The identifier of the user account.
    ///   - logger: Logger use during operation
    @inlinable
    public func listUserProficiencies(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListUserProficienciesResponse {
        let input = ListUserProficienciesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            userId: userId
        )
        return try await self.listUserProficiencies(input, logger: logger)
    }

    /// Provides summary information about the users for the specified Amazon Connect instance.
    @Sendable
    @inlinable
    public func listUsers(_ input: ListUsersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListUsersResponse {
        try await self.client.execute(
            operation: "ListUsers", 
            path: "/users-summary/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides summary information about the users for the specified Amazon Connect instance.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - logger: Logger use during operation
    @inlinable
    public func listUsers(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListUsersResponse {
        let input = ListUsersRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listUsers(input, logger: logger)
    }

    /// Returns all the available versions for the specified Amazon Connect instance and view identifier. Results will be sorted from highest to lowest.
    @Sendable
    @inlinable
    public func listViewVersions(_ input: ListViewVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListViewVersionsResponse {
        try await self.client.execute(
            operation: "ListViewVersions", 
            path: "/views/{InstanceId}/{ViewId}/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns all the available versions for the specified Amazon Connect instance and view identifier. Results will be sorted from highest to lowest.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - viewId: The identifier of the view. Both ViewArn and ViewId can be used.
    ///   - logger: Logger use during operation
    @inlinable
    public func listViewVersions(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        viewId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListViewVersionsResponse {
        let input = ListViewVersionsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            viewId: viewId
        )
        return try await self.listViewVersions(input, logger: logger)
    }

    /// Returns views in the given instance. Results are sorted primarily by type, and secondarily by name.
    @Sendable
    @inlinable
    public func listViews(_ input: ListViewsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListViewsResponse {
        try await self.client.execute(
            operation: "ListViews", 
            path: "/views/{InstanceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns views in the given instance. Results are sorted primarily by type, and secondarily by name.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - type: The type of the view.
    ///   - logger: Logger use during operation
    @inlinable
    public func listViews(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        type: ViewType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListViewsResponse {
        let input = ListViewsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            type: type
        )
        return try await self.listViews(input, logger: logger)
    }

    /// Initiates silent monitoring of a contact. The Contact Control Panel (CCP) of the user specified by userId will be set to silent monitoring mode on the contact.
    @Sendable
    @inlinable
    public func monitorContact(_ input: MonitorContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> MonitorContactResponse {
        try await self.client.execute(
            operation: "MonitorContact", 
            path: "/contact/monitor", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Initiates silent monitoring of a contact. The Contact Control Panel (CCP) of the user specified by userId will be set to silent monitoring mode on the contact.
    ///
    /// Parameters:
    ///   - allowedMonitorCapabilities: Specify which monitoring actions the user is allowed to take. For example, whether the user is allowed to escalate from silent monitoring to barge. AllowedMonitorCapabilities is required if barge is enabled.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - contactId: The identifier of the contact.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - userId: The identifier of the user account.
    ///   - logger: Logger use during operation
    @inlinable
    public func monitorContact(
        allowedMonitorCapabilities: [MonitorCapability]? = nil,
        clientToken: String? = MonitorContactRequest.idempotencyToken(),
        contactId: String,
        instanceId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> MonitorContactResponse {
        let input = MonitorContactRequest(
            allowedMonitorCapabilities: allowedMonitorCapabilities, 
            clientToken: clientToken, 
            contactId: contactId, 
            instanceId: instanceId, 
            userId: userId
        )
        return try await self.monitorContact(input, logger: logger)
    }

    /// Allows pausing an ongoing task contact.
    @Sendable
    @inlinable
    public func pauseContact(_ input: PauseContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PauseContactResponse {
        try await self.client.execute(
            operation: "PauseContact", 
            path: "/contact/pause", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Allows pausing an ongoing task contact.
    ///
    /// Parameters:
    ///   - contactFlowId: The identifier of the flow.
    ///   - contactId: The identifier of the contact.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func pauseContact(
        contactFlowId: String? = nil,
        contactId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PauseContactResponse {
        let input = PauseContactRequest(
            contactFlowId: contactFlowId, 
            contactId: contactId, 
            instanceId: instanceId
        )
        return try await self.pauseContact(input, logger: logger)
    }

    /// Changes the current status of a user or agent in Amazon Connect. If the agent is currently handling a contact, this sets the agent's next status. For more information, see Agent status and Set your next status in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func putUserStatus(_ input: PutUserStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutUserStatusResponse {
        try await self.client.execute(
            operation: "PutUserStatus", 
            path: "/users/{InstanceId}/{UserId}/status", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Changes the current status of a user or agent in Amazon Connect. If the agent is currently handling a contact, this sets the agent's next status. For more information, see Agent status and Set your next status in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - agentStatusId: The identifier of the agent status.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - userId: The identifier of the user.
    ///   - logger: Logger use during operation
    @inlinable
    public func putUserStatus(
        agentStatusId: String,
        instanceId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutUserStatusResponse {
        let input = PutUserStatusRequest(
            agentStatusId: agentStatusId, 
            instanceId: instanceId, 
            userId: userId
        )
        return try await self.putUserStatus(input, logger: logger)
    }

    /// Releases a phone number previously claimed to an Amazon Connect instance or traffic distribution group. You can call this API only in the Amazon Web Services Region where the number was claimed.  To release phone numbers from a traffic distribution group, use the ReleasePhoneNumber API, not the Amazon Connect admin website. After releasing a phone number, the phone number enters into a cooldown period for up to 180 days. It cannot be searched for or claimed again until the period has ended. If you accidentally release a phone number, contact Amazon Web ServicesSupport.  If you plan to claim and release numbers frequently, contact us for a service quota exception. Otherwise, it is possible you will be blocked from claiming and releasing any more numbers until up to 180 days past the oldest number released has expired. By default you can claim and release up to 200% of your maximum number of active phone numbers. If you claim and release phone numbers using the UI or API during a rolling 180 day cycle that exceeds 200% of your phone number service level quota, you will be blocked from claiming any more numbers until 180 days past the oldest number released has expired.  For example, if you already have 99 claimed numbers and a service level quota of 99 phone numbers, and in any 180 day period you release 99, claim 99, and then release 99, you will have exceeded the 200% limit. At that point you are blocked from claiming any more numbers until you open an Amazon Web Services support ticket.
    @Sendable
    @inlinable
    public func releasePhoneNumber(_ input: ReleasePhoneNumberRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "ReleasePhoneNumber", 
            path: "/phone-number/{PhoneNumberId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Releases a phone number previously claimed to an Amazon Connect instance or traffic distribution group. You can call this API only in the Amazon Web Services Region where the number was claimed.  To release phone numbers from a traffic distribution group, use the ReleasePhoneNumber API, not the Amazon Connect admin website. After releasing a phone number, the phone number enters into a cooldown period for up to 180 days. It cannot be searched for or claimed again until the period has ended. If you accidentally release a phone number, contact Amazon Web ServicesSupport.  If you plan to claim and release numbers frequently, contact us for a service quota exception. Otherwise, it is possible you will be blocked from claiming and releasing any more numbers until up to 180 days past the oldest number released has expired. By default you can claim and release up to 200% of your maximum number of active phone numbers. If you claim and release phone numbers using the UI or API during a rolling 180 day cycle that exceeds 200% of your phone number service level quota, you will be blocked from claiming any more numbers until 180 days past the oldest number released has expired.  For example, if you already have 99 claimed numbers and a service level quota of 99 phone numbers, and in any 180 day period you release 99, claim 99, and then release 99, you will have exceeded the 200% limit. At that point you are blocked from claiming any more numbers until you open an Amazon Web Services support ticket.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - phoneNumberId: A unique identifier for the phone number.
    ///   - logger: Logger use during operation
    @inlinable
    public func releasePhoneNumber(
        clientToken: String? = ReleasePhoneNumberRequest.idempotencyToken(),
        phoneNumberId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = ReleasePhoneNumberRequest(
            clientToken: clientToken, 
            phoneNumberId: phoneNumberId
        )
        return try await self.releasePhoneNumber(input, logger: logger)
    }

    /// Replicates an Amazon Connect instance in the specified Amazon Web Services Region and copies configuration information for Amazon Connect resources across Amazon Web Services Regions.  For more information about replicating an Amazon Connect instance, see Create a replica of your existing Amazon Connect instance in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func replicateInstance(_ input: ReplicateInstanceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ReplicateInstanceResponse {
        try await self.client.execute(
            operation: "ReplicateInstance", 
            path: "/instance/{InstanceId}/replicate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Replicates an Amazon Connect instance in the specified Amazon Web Services Region and copies configuration information for Amazon Connect resources across Amazon Web Services Regions.  For more information about replicating an Amazon Connect instance, see Create a replica of your existing Amazon Connect instance in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance. You can provide the InstanceId, or the entire ARN.
    ///   - replicaAlias: The alias for the replicated instance. The ReplicaAlias must be unique.
    ///   - replicaRegion: The Amazon Web Services Region where to replicate the Amazon Connect instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func replicateInstance(
        clientToken: String? = ReplicateInstanceRequest.idempotencyToken(),
        instanceId: String,
        replicaAlias: String,
        replicaRegion: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ReplicateInstanceResponse {
        let input = ReplicateInstanceRequest(
            clientToken: clientToken, 
            instanceId: instanceId, 
            replicaAlias: replicaAlias, 
            replicaRegion: replicaRegion
        )
        return try await self.replicateInstance(input, logger: logger)
    }

    /// Allows resuming a task contact in a paused state.
    @Sendable
    @inlinable
    public func resumeContact(_ input: ResumeContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ResumeContactResponse {
        try await self.client.execute(
            operation: "ResumeContact", 
            path: "/contact/resume", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Allows resuming a task contact in a paused state.
    ///
    /// Parameters:
    ///   - contactFlowId: The identifier of the flow.
    ///   - contactId: The identifier of the contact.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func resumeContact(
        contactFlowId: String? = nil,
        contactId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ResumeContactResponse {
        let input = ResumeContactRequest(
            contactFlowId: contactFlowId, 
            contactId: contactId, 
            instanceId: instanceId
        )
        return try await self.resumeContact(input, logger: logger)
    }

    /// When a contact is being recorded, and the recording has been suspended using SuspendContactRecording, this API resumes recording whatever recording is selected in the flow configuration: call, screen, or both. If only call recording or only screen recording is enabled, then it would resume. Voice and screen recordings are supported.
    @Sendable
    @inlinable
    public func resumeContactRecording(_ input: ResumeContactRecordingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ResumeContactRecordingResponse {
        try await self.client.execute(
            operation: "ResumeContactRecording", 
            path: "/contact/resume-recording", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// When a contact is being recorded, and the recording has been suspended using SuspendContactRecording, this API resumes recording whatever recording is selected in the flow configuration: call, screen, or both. If only call recording or only screen recording is enabled, then it would resume. Voice and screen recordings are supported.
    ///
    /// Parameters:
    ///   - contactId: The identifier of the contact.
    ///   - contactRecordingType: The type of recording being operated on.
    ///   - initialContactId: The identifier of the contact. This is the identifier of the contact associated with the first interaction with the contact center.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func resumeContactRecording(
        contactId: String,
        contactRecordingType: ContactRecordingType? = nil,
        initialContactId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ResumeContactRecordingResponse {
        let input = ResumeContactRecordingRequest(
            contactId: contactId, 
            contactRecordingType: contactRecordingType, 
            initialContactId: initialContactId, 
            instanceId: instanceId
        )
        return try await self.resumeContactRecording(input, logger: logger)
    }

    /// Searches AgentStatuses in an Amazon Connect instance, with optional filtering.
    @Sendable
    @inlinable
    public func searchAgentStatuses(_ input: SearchAgentStatusesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchAgentStatusesResponse {
        try await self.client.execute(
            operation: "SearchAgentStatuses", 
            path: "/search-agent-statuses", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches AgentStatuses in an Amazon Connect instance, with optional filtering.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - searchCriteria: The search criteria to be used to return agent statuses.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchAgentStatuses(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchCriteria: AgentStatusSearchCriteria? = nil,
        searchFilter: AgentStatusSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchAgentStatusesResponse {
        let input = SearchAgentStatusesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return try await self.searchAgentStatuses(input, logger: logger)
    }

    /// Searches for available phone numbers that you can claim to your Amazon Connect instance or traffic distribution group. If the provided TargetArn is a traffic distribution group, you can call this API in both Amazon Web Services Regions associated with the traffic distribution group.
    @Sendable
    @inlinable
    public func searchAvailablePhoneNumbers(_ input: SearchAvailablePhoneNumbersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchAvailablePhoneNumbersResponse {
        try await self.client.execute(
            operation: "SearchAvailablePhoneNumbers", 
            path: "/phone-number/search-available", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for available phone numbers that you can claim to your Amazon Connect instance or traffic distribution group. If the provided TargetArn is a traffic distribution group, you can call this API in both Amazon Web Services Regions associated with the traffic distribution group.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance that phone numbers are claimed to. You can find the instance ID in the Amazon Resource Name (ARN) of the instance. You must enter InstanceId or TargetArn.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - phoneNumberCountryCode: The ISO country code.
    ///   - phoneNumberPrefix: The prefix of the phone number. If provided, it must contain + as part of the country code.
    ///   - phoneNumberType: The type of phone number.
    ///   - targetArn: The Amazon Resource Name (ARN) for Amazon Connect instances or traffic distribution groups that phone number inbound traffic is routed through. You must enter InstanceId or TargetArn.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchAvailablePhoneNumbers(
        instanceId: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        phoneNumberCountryCode: PhoneNumberCountryCode,
        phoneNumberPrefix: String? = nil,
        phoneNumberType: PhoneNumberType,
        targetArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchAvailablePhoneNumbersResponse {
        let input = SearchAvailablePhoneNumbersRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            phoneNumberCountryCode: phoneNumberCountryCode, 
            phoneNumberPrefix: phoneNumberPrefix, 
            phoneNumberType: phoneNumberType, 
            targetArn: targetArn
        )
        return try await self.searchAvailablePhoneNumbers(input, logger: logger)
    }

    /// Searches the flow modules in an Amazon Connect instance, with optional filtering.
    @Sendable
    @inlinable
    public func searchContactFlowModules(_ input: SearchContactFlowModulesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchContactFlowModulesResponse {
        try await self.client.execute(
            operation: "SearchContactFlowModules", 
            path: "/search-contact-flow-modules", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches the flow modules in an Amazon Connect instance, with optional filtering.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - searchCriteria: The search criteria to be used to return flow modules.  The name and description fields support "contains" queries with a minimum of 2 characters and a maximum of 25 characters. Any queries with character lengths outside of this range will result in invalid results.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchContactFlowModules(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchCriteria: ContactFlowModuleSearchCriteria? = nil,
        searchFilter: ContactFlowModuleSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchContactFlowModulesResponse {
        let input = SearchContactFlowModulesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return try await self.searchContactFlowModules(input, logger: logger)
    }

    /// Searches the flows in an Amazon Connect instance, with optional filtering.
    @Sendable
    @inlinable
    public func searchContactFlows(_ input: SearchContactFlowsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchContactFlowsResponse {
        try await self.client.execute(
            operation: "SearchContactFlows", 
            path: "/search-contact-flows", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches the flows in an Amazon Connect instance, with optional filtering.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - searchCriteria: The search criteria to be used to return flows.  The name and description fields support "contains" queries with a minimum of 2 characters and a maximum of 25 characters. Any queries with character lengths outside of this range will result in invalid results.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchContactFlows(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchCriteria: ContactFlowSearchCriteria? = nil,
        searchFilter: ContactFlowSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchContactFlowsResponse {
        let input = SearchContactFlowsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return try await self.searchContactFlows(input, logger: logger)
    }

    /// Searches contacts in an Amazon Connect instance.
    @Sendable
    @inlinable
    public func searchContacts(_ input: SearchContactsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchContactsResponse {
        try await self.client.execute(
            operation: "SearchContacts", 
            path: "/search-contacts", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches contacts in an Amazon Connect instance.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - searchCriteria: The search criteria to be used to return contacts.
    ///   - sort: Specifies a field to sort by and a sort order.
    ///   - timeRange: Time range that you want to search results.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchContacts(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchCriteria: SearchCriteria? = nil,
        sort: Sort? = nil,
        timeRange: SearchContactsTimeRange,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchContactsResponse {
        let input = SearchContactsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchCriteria: searchCriteria, 
            sort: sort, 
            timeRange: timeRange
        )
        return try await self.searchContacts(input, logger: logger)
    }

    /// Searches email address in an instance, with optional filtering.
    @Sendable
    @inlinable
    public func searchEmailAddresses(_ input: SearchEmailAddressesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchEmailAddressesResponse {
        try await self.client.execute(
            operation: "SearchEmailAddresses", 
            path: "/search-email-addresses", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches email address in an instance, with optional filtering.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - searchCriteria: The search criteria to be used to return email addresses.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchEmailAddresses(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchCriteria: EmailAddressSearchCriteria? = nil,
        searchFilter: EmailAddressSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchEmailAddressesResponse {
        let input = SearchEmailAddressesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return try await self.searchEmailAddresses(input, logger: logger)
    }

    /// Searches the hours of operation overrides.
    @Sendable
    @inlinable
    public func searchHoursOfOperationOverrides(_ input: SearchHoursOfOperationOverridesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchHoursOfOperationOverridesResponse {
        try await self.client.execute(
            operation: "SearchHoursOfOperationOverrides", 
            path: "/search-hours-of-operation-overrides", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches the hours of operation overrides.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - maxResults: The maximum number of results to return per page. Valid Range: Minimum value of 1. Maximum value of 100.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results. Length Constraints: Minimum length of 1. Maximum length of 2500.
    ///   - searchCriteria: The search criteria to be used to return hours of operations overrides.
    ///   - searchFilter: 
    ///   - logger: Logger use during operation
    @inlinable
    public func searchHoursOfOperationOverrides(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchCriteria: HoursOfOperationOverrideSearchCriteria? = nil,
        searchFilter: HoursOfOperationSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchHoursOfOperationOverridesResponse {
        let input = SearchHoursOfOperationOverridesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return try await self.searchHoursOfOperationOverrides(input, logger: logger)
    }

    /// Searches the hours of operation in an Amazon Connect instance, with optional filtering.
    @Sendable
    @inlinable
    public func searchHoursOfOperations(_ input: SearchHoursOfOperationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchHoursOfOperationsResponse {
        try await self.client.execute(
            operation: "SearchHoursOfOperations", 
            path: "/search-hours-of-operations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches the hours of operation in an Amazon Connect instance, with optional filtering.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - searchCriteria: The search criteria to be used to return hours of operations.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchHoursOfOperations(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchCriteria: HoursOfOperationSearchCriteria? = nil,
        searchFilter: HoursOfOperationSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchHoursOfOperationsResponse {
        let input = SearchHoursOfOperationsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return try await self.searchHoursOfOperations(input, logger: logger)
    }

    /// Searches predefined attributes that meet certain criteria. Predefined attributes are attributes in an Amazon Connect instance that can be used to route contacts to an agent or pools of agents within a queue. For more information, see Create predefined attributes for routing contacts to agents.
    @Sendable
    @inlinable
    public func searchPredefinedAttributes(_ input: SearchPredefinedAttributesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchPredefinedAttributesResponse {
        try await self.client.execute(
            operation: "SearchPredefinedAttributes", 
            path: "/search-predefined-attributes", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches predefined attributes that meet certain criteria. Predefined attributes are attributes in an Amazon Connect instance that can be used to route contacts to an agent or pools of agents within a queue. For more information, see Create predefined attributes for routing contacts to agents.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - searchCriteria: The search criteria to be used to return predefined attributes.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchPredefinedAttributes(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchCriteria: PredefinedAttributeSearchCriteria? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchPredefinedAttributesResponse {
        let input = SearchPredefinedAttributesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchCriteria: searchCriteria
        )
        return try await self.searchPredefinedAttributes(input, logger: logger)
    }

    /// Searches prompts in an Amazon Connect instance, with optional filtering.
    @Sendable
    @inlinable
    public func searchPrompts(_ input: SearchPromptsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchPromptsResponse {
        try await self.client.execute(
            operation: "SearchPrompts", 
            path: "/search-prompts", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches prompts in an Amazon Connect instance, with optional filtering.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - searchCriteria: The search criteria to be used to return prompts.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchPrompts(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchCriteria: PromptSearchCriteria? = nil,
        searchFilter: PromptSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchPromptsResponse {
        let input = SearchPromptsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return try await self.searchPrompts(input, logger: logger)
    }

    /// Searches queues in an Amazon Connect instance, with optional filtering.
    @Sendable
    @inlinable
    public func searchQueues(_ input: SearchQueuesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchQueuesResponse {
        try await self.client.execute(
            operation: "SearchQueues", 
            path: "/search-queues", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches queues in an Amazon Connect instance, with optional filtering.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - searchCriteria: The search criteria to be used to return queues.  The name and description fields support "contains" queries with a minimum of 2 characters and a maximum of 25 characters. Any queries with character lengths outside of this range will throw invalid results.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchQueues(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchCriteria: QueueSearchCriteria? = nil,
        searchFilter: QueueSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchQueuesResponse {
        let input = SearchQueuesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return try await self.searchQueues(input, logger: logger)
    }

    /// Searches quick connects in an Amazon Connect instance, with optional filtering.
    @Sendable
    @inlinable
    public func searchQuickConnects(_ input: SearchQuickConnectsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchQuickConnectsResponse {
        try await self.client.execute(
            operation: "SearchQuickConnects", 
            path: "/search-quick-connects", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches quick connects in an Amazon Connect instance, with optional filtering.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - searchCriteria: The search criteria to be used to return quick connects.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchQuickConnects(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchCriteria: QuickConnectSearchCriteria? = nil,
        searchFilter: QuickConnectSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchQuickConnectsResponse {
        let input = SearchQuickConnectsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return try await self.searchQuickConnects(input, logger: logger)
    }

    /// Searches tags used in an Amazon Connect instance using optional search criteria.
    @Sendable
    @inlinable
    public func searchResourceTags(_ input: SearchResourceTagsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchResourceTagsResponse {
        try await self.client.execute(
            operation: "SearchResourceTags", 
            path: "/search-resource-tags", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches tags used in an Amazon Connect instance using optional search criteria.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - resourceTypes: The list of resource types to be used to search tags from. If not provided or if any empty list is provided, this API will search from all supported resource types. Note that lowercase and - are required.  Supported resource types    agent   agent-state   routing-profile   standard-queue   security-profile   operating-hours   prompt   contact-flow   flow- module   transfer-destination (also known as quick connect)
    ///   - searchCriteria: The search criteria to be used to return tags.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchResourceTags(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resourceTypes: [String]? = nil,
        searchCriteria: ResourceTagsSearchCriteria? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchResourceTagsResponse {
        let input = SearchResourceTagsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            resourceTypes: resourceTypes, 
            searchCriteria: searchCriteria
        )
        return try await self.searchResourceTags(input, logger: logger)
    }

    /// Searches routing profiles in an Amazon Connect instance, with optional filtering.   SearchRoutingProfiles does not populate LastModifiedRegion, LastModifiedTime, MediaConcurrencies.CrossChannelBehavior, and AgentAvailabilityTimer in its response, but DescribeRoutingProfile does.
    @Sendable
    @inlinable
    public func searchRoutingProfiles(_ input: SearchRoutingProfilesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchRoutingProfilesResponse {
        try await self.client.execute(
            operation: "SearchRoutingProfiles", 
            path: "/search-routing-profiles", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches routing profiles in an Amazon Connect instance, with optional filtering.   SearchRoutingProfiles does not populate LastModifiedRegion, LastModifiedTime, MediaConcurrencies.CrossChannelBehavior, and AgentAvailabilityTimer in its response, but DescribeRoutingProfile does.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - searchCriteria: The search criteria to be used to return routing profiles.  The name and description fields support "contains" queries with a minimum of 2 characters and a maximum of 25 characters. Any queries with character lengths outside of this range will throw invalid results.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchRoutingProfiles(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchCriteria: RoutingProfileSearchCriteria? = nil,
        searchFilter: RoutingProfileSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchRoutingProfilesResponse {
        let input = SearchRoutingProfilesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return try await self.searchRoutingProfiles(input, logger: logger)
    }

    /// Searches security profiles in an Amazon Connect instance, with optional filtering. For information about security profiles, see Security Profiles in the Amazon Connect Administrator Guide. For a mapping of the API name and user interface name of the security profile permissions, see List of security profile permissions.
    @Sendable
    @inlinable
    public func searchSecurityProfiles(_ input: SearchSecurityProfilesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchSecurityProfilesResponse {
        try await self.client.execute(
            operation: "SearchSecurityProfiles", 
            path: "/search-security-profiles", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches security profiles in an Amazon Connect instance, with optional filtering. For information about security profiles, see Security Profiles in the Amazon Connect Administrator Guide. For a mapping of the API name and user interface name of the security profile permissions, see List of security profile permissions.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - searchCriteria: The search criteria to be used to return security profiles.   The name field support "contains" queries with a minimum of 2 characters and maximum of 25 characters. Any queries with character lengths outside of this range will throw invalid results.   The currently supported value for FieldName: name
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchSecurityProfiles(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchCriteria: SecurityProfileSearchCriteria? = nil,
        searchFilter: SecurityProfilesSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchSecurityProfilesResponse {
        let input = SearchSecurityProfilesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return try await self.searchSecurityProfiles(input, logger: logger)
    }

    /// Searches UserHierarchyGroups in an Amazon Connect instance, with optional filtering.  The UserHierarchyGroup with "LevelId": "0" is the foundation for building levels on top of an instance. It is not user-definable, nor is it visible in the UI.
    @Sendable
    @inlinable
    public func searchUserHierarchyGroups(_ input: SearchUserHierarchyGroupsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchUserHierarchyGroupsResponse {
        try await self.client.execute(
            operation: "SearchUserHierarchyGroups", 
            path: "/search-user-hierarchy-groups", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches UserHierarchyGroups in an Amazon Connect instance, with optional filtering.  The UserHierarchyGroup with "LevelId": "0" is the foundation for building levels on top of an instance. It is not user-definable, nor is it visible in the UI.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous response in the next request to retrieve the next set of results.
    ///   - searchCriteria: The search criteria to be used to return UserHierarchyGroups.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchUserHierarchyGroups(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchCriteria: UserHierarchyGroupSearchCriteria? = nil,
        searchFilter: UserHierarchyGroupSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchUserHierarchyGroupsResponse {
        let input = SearchUserHierarchyGroupsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return try await self.searchUserHierarchyGroups(input, logger: logger)
    }

    /// Searches users in an Amazon Connect instance, with optional filtering.    AfterContactWorkTimeLimit is returned in milliseconds.
    @Sendable
    @inlinable
    public func searchUsers(_ input: SearchUsersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchUsersResponse {
        try await self.client.execute(
            operation: "SearchUsers", 
            path: "/search-users", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches users in an Amazon Connect instance, with optional filtering.    AfterContactWorkTimeLimit is returned in milliseconds.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - searchCriteria: 
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchUsers(
        instanceId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        searchCriteria: UserSearchCriteria? = nil,
        searchFilter: UserSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchUsersResponse {
        let input = SearchUsersRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return try await self.searchUsers(input, logger: logger)
    }

    /// Searches for vocabularies within a specific Amazon Connect instance using State, NameStartsWith, and LanguageCode.
    @Sendable
    @inlinable
    public func searchVocabularies(_ input: SearchVocabulariesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchVocabulariesResponse {
        try await self.client.execute(
            operation: "SearchVocabularies", 
            path: "/vocabulary-summary/{InstanceId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for vocabularies within a specific Amazon Connect instance using State, NameStartsWith, and LanguageCode.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - languageCode: The language code of the vocabulary entries. For a list of languages and their corresponding language codes, see
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nameStartsWith: The starting pattern of the name of the vocabulary.
    ///   - nextToken: The token for the next set of results. Use the value returned in the previous
    ///   - state: The current state of the custom vocabulary.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchVocabularies(
        instanceId: String,
        languageCode: VocabularyLanguageCode? = nil,
        maxResults: Int? = nil,
        nameStartsWith: String? = nil,
        nextToken: String? = nil,
        state: VocabularyState? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchVocabulariesResponse {
        let input = SearchVocabulariesRequest(
            instanceId: instanceId, 
            languageCode: languageCode, 
            maxResults: maxResults, 
            nameStartsWith: nameStartsWith, 
            nextToken: nextToken, 
            state: state
        )
        return try await self.searchVocabularies(input, logger: logger)
    }

    /// Processes chat integration events from Amazon Web Services or external integrations to Amazon Connect. A chat integration event includes:   SourceId, DestinationId, and Subtype: a set of identifiers, uniquely representing a chat   ChatEvent: details of the chat action to perform such as sending a message, event, or disconnecting from a chat   When a chat integration event is sent with chat identifiers that do not map to an active chat contact, a new chat contact is also created before handling chat action.  Access to this API is currently restricted to Amazon Web Services End User Messaging for supporting SMS integration.
    @Sendable
    @inlinable
    public func sendChatIntegrationEvent(_ input: SendChatIntegrationEventRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SendChatIntegrationEventResponse {
        try await self.client.execute(
            operation: "SendChatIntegrationEvent", 
            path: "/chat-integration-event", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Processes chat integration events from Amazon Web Services or external integrations to Amazon Connect. A chat integration event includes:   SourceId, DestinationId, and Subtype: a set of identifiers, uniquely representing a chat   ChatEvent: details of the chat action to perform such as sending a message, event, or disconnecting from a chat   When a chat integration event is sent with chat identifiers that do not map to an active chat contact, a new chat contact is also created before handling chat action.  Access to this API is currently restricted to Amazon Web Services End User Messaging for supporting SMS integration.
    ///
    /// Parameters:
    ///   - destinationId: Chat system identifier, used in part to uniquely identify chat. This is associated with the Amazon Connect instance and flow to be used to start chats. For Server Migration Service, this is the phone number destination of inbound Server Migration Service messages represented by an Amazon Web Services End User Messaging phone number ARN.
    ///   - event: Chat integration event payload
    ///   - newSessionDetails: Contact properties to apply when starting a new chat. If the integration event is handled with an existing chat, this is ignored.
    ///   - sourceId: External identifier of chat customer participant, used in part to uniquely identify a chat. For SMS, this is the E164 phone number of the chat customer participant.
    ///   - subtype: Classification of a channel. This is used in part to uniquely identify chat.  Valid value: ["connect:sms", connect:"WhatsApp"]
    ///   - logger: Logger use during operation
    @inlinable
    public func sendChatIntegrationEvent(
        destinationId: String,
        event: ChatEvent,
        newSessionDetails: NewSessionDetails? = nil,
        sourceId: String,
        subtype: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SendChatIntegrationEventResponse {
        let input = SendChatIntegrationEventRequest(
            destinationId: destinationId, 
            event: event, 
            newSessionDetails: newSessionDetails, 
            sourceId: sourceId, 
            subtype: subtype
        )
        return try await self.sendChatIntegrationEvent(input, logger: logger)
    }

    /// Send outbound email for outbound campaigns. For more information about outbound campaigns, see Set up Amazon Connect outbound campaigns.  Only the Amazon Connect outbound campaigns service principal is allowed to assume a role in your account and call this API.
    @Sendable
    @inlinable
    public func sendOutboundEmail(_ input: SendOutboundEmailRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SendOutboundEmailResponse {
        try await self.client.execute(
            operation: "SendOutboundEmail", 
            path: "/instance/{InstanceId}/outbound-email", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Send outbound email for outbound campaigns. For more information about outbound campaigns, see Set up Amazon Connect outbound campaigns.  Only the Amazon Connect outbound campaigns service principal is allowed to assume a role in your account and call this API.
    ///
    /// Parameters:
    ///   - additionalRecipients: The additional recipients address of the email in CC.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - destinationEmailAddress: The email address to send the email to.
    ///   - emailMessage: The email message body to be sent to the newly created email.
    ///   - fromEmailAddress: The email address to be used for sending email.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - sourceCampaign: A Campaign object need for Campaign traffic type.
    ///   - trafficType: Denotes the class of traffic.  Only the CAMPAIGN traffic type is supported.
    ///   - logger: Logger use during operation
    @inlinable
    public func sendOutboundEmail(
        additionalRecipients: OutboundAdditionalRecipients? = nil,
        clientToken: String? = SendOutboundEmailRequest.idempotencyToken(),
        destinationEmailAddress: EmailAddressInfo,
        emailMessage: OutboundEmailContent,
        fromEmailAddress: EmailAddressInfo,
        instanceId: String,
        sourceCampaign: SourceCampaign? = nil,
        trafficType: TrafficType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SendOutboundEmailResponse {
        let input = SendOutboundEmailRequest(
            additionalRecipients: additionalRecipients, 
            clientToken: clientToken, 
            destinationEmailAddress: destinationEmailAddress, 
            emailMessage: emailMessage, 
            fromEmailAddress: fromEmailAddress, 
            instanceId: instanceId, 
            sourceCampaign: sourceCampaign, 
            trafficType: trafficType
        )
        return try await self.sendOutboundEmail(input, logger: logger)
    }

    /// Provides a pre-signed Amazon S3 URL in response for uploading your content.  You may only use this API to upload attachments to an Amazon Connect Case or Amazon Connect Email.
    @Sendable
    @inlinable
    public func startAttachedFileUpload(_ input: StartAttachedFileUploadRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartAttachedFileUploadResponse {
        try await self.client.execute(
            operation: "StartAttachedFileUpload", 
            path: "/attached-files/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides a pre-signed Amazon S3 URL in response for uploading your content.  You may only use this API to upload attachments to an Amazon Connect Case or Amazon Connect Email.
    ///
    /// Parameters:
    ///   - associatedResourceArn: The resource to which the attached file is (being) uploaded to. The supported resources are Cases and Email.  This value must be a valid ARN.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - createdBy: Represents the identity that created the file.
    ///   - fileName: A case-sensitive name of the attached file being uploaded.
    ///   - fileSizeInBytes: The size of the attached file in bytes.
    ///   - fileUseCaseType: The use case for the file.  Only ATTACHMENTS are supported.
    ///   - instanceId: The unique identifier of the Amazon Connect instance.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - urlExpiryInSeconds: Optional override for the expiry of the pre-signed S3 URL in seconds. The default value is 300.
    ///   - logger: Logger use during operation
    @inlinable
    public func startAttachedFileUpload(
        associatedResourceArn: String,
        clientToken: String? = StartAttachedFileUploadRequest.idempotencyToken(),
        createdBy: CreatedByInfo? = nil,
        fileName: String,
        fileSizeInBytes: Int64,
        fileUseCaseType: FileUseCaseType,
        instanceId: String,
        tags: [String: String]? = nil,
        urlExpiryInSeconds: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartAttachedFileUploadResponse {
        let input = StartAttachedFileUploadRequest(
            associatedResourceArn: associatedResourceArn, 
            clientToken: clientToken, 
            createdBy: createdBy, 
            fileName: fileName, 
            fileSizeInBytes: fileSizeInBytes, 
            fileUseCaseType: fileUseCaseType, 
            instanceId: instanceId, 
            tags: tags, 
            urlExpiryInSeconds: urlExpiryInSeconds
        )
        return try await self.startAttachedFileUpload(input, logger: logger)
    }

    /// Initiates a flow to start a new chat for the customer. Response of this API provides a token required to obtain credentials from the CreateParticipantConnection API in the Amazon Connect Participant Service. When a new chat contact is successfully created, clients must subscribe to the participant’s connection for the created chat within 5 minutes. This is achieved by invoking CreateParticipantConnection with WEBSOCKET and CONNECTION_CREDENTIALS.  A 429 error occurs in the following situations:   API rate limit is exceeded. API TPS throttling returns a TooManyRequests exception.   The quota for concurrent active chats is exceeded. Active chat throttling returns a LimitExceededException.   If you use the ChatDurationInMinutes parameter and receive a 400 error, your account may not support the ability to configure custom chat durations. For more information, contact Amazon Web ServicesSupport.  For more information about chat, see the following topics in the Amazon Connect Administrator Guide:     Concepts: Web and mobile messaging capabilities in Amazon Connect     Amazon Connect Chat security best practices
    @Sendable
    @inlinable
    public func startChatContact(_ input: StartChatContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartChatContactResponse {
        try await self.client.execute(
            operation: "StartChatContact", 
            path: "/contact/chat", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Initiates a flow to start a new chat for the customer. Response of this API provides a token required to obtain credentials from the CreateParticipantConnection API in the Amazon Connect Participant Service. When a new chat contact is successfully created, clients must subscribe to the participant’s connection for the created chat within 5 minutes. This is achieved by invoking CreateParticipantConnection with WEBSOCKET and CONNECTION_CREDENTIALS.  A 429 error occurs in the following situations:   API rate limit is exceeded. API TPS throttling returns a TooManyRequests exception.   The quota for concurrent active chats is exceeded. Active chat throttling returns a LimitExceededException.   If you use the ChatDurationInMinutes parameter and receive a 400 error, your account may not support the ability to configure custom chat durations. For more information, contact Amazon Web ServicesSupport.  For more information about chat, see the following topics in the Amazon Connect Administrator Guide:     Concepts: Web and mobile messaging capabilities in Amazon Connect     Amazon Connect Chat security best practices
    ///
    /// Parameters:
    ///   - attributes: A custom key-value pair using an attribute map. The attributes are standard Amazon Connect attributes. They can be accessed in flows just like any other contact attributes.  There can be up to 32,768 UTF-8 bytes across all key-value pairs per contact. Attribute keys can include only alphanumeric, dash, and underscore characters.
    ///   - chatDurationInMinutes: The total duration of the newly started chat session. If not specified, the chat session duration defaults to 25 hour. The minimum configurable time is 60 minutes. The maximum configurable time is 10,080 minutes (7 days).
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - contactFlowId: The identifier of the flow for initiating the chat. To see the ContactFlowId in the Amazon Connect admin website, on the navigation menu go to Routing, Flows. Choose the flow. On the flow page, under the name of the flow, choose Show additional flow information. The ContactFlowId is the last part of the ARN, shown here in bold:  arn:aws:connect:us-west-2:xxxxxxxxxxxx:instance/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/contact-flow/846ec553-a005-41c0-8341-xxxxxxxxxxxx
    ///   - customerId: The customer's identification number. For example, the CustomerId may be a customer number from your CRM.
    ///   - initialMessage: The initial message to be sent to the newly created chat.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - participantDetails: Information identifying the participant.
    ///   - persistentChat: Enable persistent chats. For more information about enabling persistent chat, and for example use cases and how to configure for them, see Enable persistent chat.
    ///   - relatedContactId: The unique identifier for an Amazon Connect contact. This identifier is related to the chat starting.  You cannot provide data for both RelatedContactId and PersistentChat.
    ///   - segmentAttributes: A set of system defined key-value pairs stored on individual contact segments using an attribute map. The attributes are standard Amazon Connect attributes. They can be accessed in flows. Attribute keys can include only alphanumeric, -, and _. This field can be used to show channel subtype, such as connect:Guide.  The types application/vnd.amazonaws.connect.message.interactive and application/vnd.amazonaws.connect.message.interactive.response must be present in the SupportedMessagingContentTypes field of this API in order to set SegmentAttributes as { "connect:Subtype": {"valueString" : "connect:Guide" }}.
    ///   - supportedMessagingContentTypes: The supported chat message content types. Supported types are text/plain, text/markdown, application/json, application/vnd.amazonaws.connect.message.interactive, and application/vnd.amazonaws.connect.message.interactive.response.  Content types must always contain text/plain. You can then put any other supported type in the list. For example, all the following lists are valid because they contain text/plain: [text/plain, text/markdown, application/json], [text/markdown, text/plain], [text/plain, application/json, application/vnd.amazonaws.connect.message.interactive.response].   The type application/vnd.amazonaws.connect.message.interactive is required to use the Show view flow block.
    ///   - logger: Logger use during operation
    @inlinable
    public func startChatContact(
        attributes: [String: String]? = nil,
        chatDurationInMinutes: Int? = nil,
        clientToken: String? = StartChatContactRequest.idempotencyToken(),
        contactFlowId: String,
        customerId: String? = nil,
        initialMessage: ChatMessage? = nil,
        instanceId: String,
        participantDetails: ParticipantDetails,
        persistentChat: PersistentChat? = nil,
        relatedContactId: String? = nil,
        segmentAttributes: [String: SegmentAttributeValue]? = nil,
        supportedMessagingContentTypes: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartChatContactResponse {
        let input = StartChatContactRequest(
            attributes: attributes, 
            chatDurationInMinutes: chatDurationInMinutes, 
            clientToken: clientToken, 
            contactFlowId: contactFlowId, 
            customerId: customerId, 
            initialMessage: initialMessage, 
            instanceId: instanceId, 
            participantDetails: participantDetails, 
            persistentChat: persistentChat, 
            relatedContactId: relatedContactId, 
            segmentAttributes: segmentAttributes, 
            supportedMessagingContentTypes: supportedMessagingContentTypes
        )
        return try await self.startChatContact(input, logger: logger)
    }

    /// Starts an empty evaluation in the specified Amazon Connect instance, using the given evaluation form for the particular contact. The evaluation form version used for the contact evaluation corresponds to the currently activated version. If no version is activated for the evaluation form, the contact evaluation cannot be started.   Evaluations created through the public API do not contain answer values suggested from automation.
    @Sendable
    @inlinable
    public func startContactEvaluation(_ input: StartContactEvaluationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartContactEvaluationResponse {
        try await self.client.execute(
            operation: "StartContactEvaluation", 
            path: "/contact-evaluations/{InstanceId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts an empty evaluation in the specified Amazon Connect instance, using the given evaluation form for the particular contact. The evaluation form version used for the contact evaluation corresponds to the currently activated version. If no version is activated for the evaluation form, the contact evaluation cannot be started.   Evaluations created through the public API do not contain answer values suggested from automation.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - contactId: The identifier of the contact in this instance of Amazon Connect.
    ///   - evaluationFormId: The unique identifier for the evaluation form.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func startContactEvaluation(
        clientToken: String? = StartContactEvaluationRequest.idempotencyToken(),
        contactId: String,
        evaluationFormId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartContactEvaluationResponse {
        let input = StartContactEvaluationRequest(
            clientToken: clientToken, 
            contactId: contactId, 
            evaluationFormId: evaluationFormId, 
            instanceId: instanceId
        )
        return try await self.startContactEvaluation(input, logger: logger)
    }

    /// Starts recording the contact:    If the API is called before the agent joins the call, recording starts when the agent joins the call.   If the API is called after the agent joins the call, recording starts at the time of the API call.   StartContactRecording is a one-time action. For example, if you use StopContactRecording to stop recording an ongoing call, you can't use StartContactRecording to restart it. For scenarios where the recording has started and you want to suspend and resume it, such as when collecting sensitive information (for example, a credit card number), use SuspendContactRecording and ResumeContactRecording. You can use this API to override the recording behavior configured in the Set recording behavior block. Only voice recordings are supported at this time.
    @Sendable
    @inlinable
    public func startContactRecording(_ input: StartContactRecordingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartContactRecordingResponse {
        try await self.client.execute(
            operation: "StartContactRecording", 
            path: "/contact/start-recording", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts recording the contact:    If the API is called before the agent joins the call, recording starts when the agent joins the call.   If the API is called after the agent joins the call, recording starts at the time of the API call.   StartContactRecording is a one-time action. For example, if you use StopContactRecording to stop recording an ongoing call, you can't use StartContactRecording to restart it. For scenarios where the recording has started and you want to suspend and resume it, such as when collecting sensitive information (for example, a credit card number), use SuspendContactRecording and ResumeContactRecording. You can use this API to override the recording behavior configured in the Set recording behavior block. Only voice recordings are supported at this time.
    ///
    /// Parameters:
    ///   - contactId: The identifier of the contact.
    ///   - initialContactId: The identifier of the contact. This is the identifier of the contact associated with the first interaction with the contact center.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - voiceRecordingConfiguration: The person being recorded.
    ///   - logger: Logger use during operation
    @inlinable
    public func startContactRecording(
        contactId: String,
        initialContactId: String,
        instanceId: String,
        voiceRecordingConfiguration: VoiceRecordingConfiguration,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartContactRecordingResponse {
        let input = StartContactRecordingRequest(
            contactId: contactId, 
            initialContactId: initialContactId, 
            instanceId: instanceId, 
            voiceRecordingConfiguration: voiceRecordingConfiguration
        )
        return try await self.startContactRecording(input, logger: logger)
    }

    ///  Initiates real-time message streaming for a new chat contact. For more information about message streaming, see Enable real-time chat message streaming in the Amazon Connect Administrator Guide. For more information about chat, see the following topics in the Amazon Connect Administrator Guide:     Concepts: Web and mobile messaging capabilities in Amazon Connect     Amazon Connect Chat security best practices
    @Sendable
    @inlinable
    public func startContactStreaming(_ input: StartContactStreamingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartContactStreamingResponse {
        try await self.client.execute(
            operation: "StartContactStreaming", 
            path: "/contact/start-streaming", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Initiates real-time message streaming for a new chat contact. For more information about message streaming, see Enable real-time chat message streaming in the Amazon Connect Administrator Guide. For more information about chat, see the following topics in the Amazon Connect Administrator Guide:     Concepts: Web and mobile messaging capabilities in Amazon Connect     Amazon Connect Chat security best practices
    ///
    /// Parameters:
    ///   - chatStreamingConfiguration: The streaming configuration, such as the Amazon SNS streaming endpoint.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - contactId: The identifier of the contact. This is the identifier of the contact associated with the first interaction with the contact center.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func startContactStreaming(
        chatStreamingConfiguration: ChatStreamingConfiguration,
        clientToken: String = StartContactStreamingRequest.idempotencyToken(),
        contactId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartContactStreamingResponse {
        let input = StartContactStreamingRequest(
            chatStreamingConfiguration: chatStreamingConfiguration, 
            clientToken: clientToken, 
            contactId: contactId, 
            instanceId: instanceId
        )
        return try await self.startContactStreaming(input, logger: logger)
    }

    /// Creates an inbound email contact and initiates a flow to start the email contact for the customer. Response of this API provides the ContactId of the email contact created.
    @Sendable
    @inlinable
    public func startEmailContact(_ input: StartEmailContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartEmailContactResponse {
        try await self.client.execute(
            operation: "StartEmailContact", 
            path: "/contact/email", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an inbound email contact and initiates a flow to start the email contact for the customer. Response of this API provides the ContactId of the email contact created.
    ///
    /// Parameters:
    ///   - additionalRecipients: The addtional recipients address of the email.
    ///   - attachments: List of S3 presigned URLs of email attachments and their file name.
    ///   - attributes: A custom key-value pair using an attribute map. The attributes are standard Amazon Connect attributes, and can be accessed in flows just like any other contact attributes. There can be up to 32,768 UTF-8 bytes across all key-value pairs per contact. Attribute keys can include only alphanumeric, dash, and underscore characters.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - contactFlowId: The identifier of the flow for initiating the emails. To see the ContactFlowId in the Amazon Connect admin website, on the navigation menu go to Routing, Flows. Choose the flow. On the flow page, under the name of the flow, choose Show additional flow information. The ContactFlowId is the last part of the ARN, shown here in bold:  arn:aws:connect:us-west-2:xxxxxxxxxxxx:instance/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/contact-flow/846ec553-a005-41c0-8341-xxxxxxxxxxxx
    ///   - description: A description of the email contact.
    ///   - destinationEmailAddress: The email address associated with the Amazon Connect instance.
    ///   - emailMessage: The email message body to be sent to the newly created email.
    ///   - fromEmailAddress: The email address of the customer.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of a email that is shown to an agent in the Contact Control Panel (CCP).
    ///   - references: A formatted URL that is shown to an agent in the Contact Control Panel (CCP). Emails can have the following reference types at the time of creation: URL | NUMBER | STRING | DATE. EMAIL | EMAIL_MESSAGE |ATTACHMENT are not a supported reference type during email creation.
    ///   - relatedContactId: The contactId that is related to this contact. Linking emails together by using RelatedContactID copies over contact attributes from the related email contact to the new email contact. All updates to user-defined attributes in the new email contact are limited to the individual contact ID. There are no limits to the number of contacts that can be linked by using RelatedContactId.
    ///   - segmentAttributes: A set of system defined key-value pairs stored on individual contact segments using an attribute map. The attributes are standard Amazon Connect attributes. They can be accessed in flows. Attribute keys can include only alphanumeric, -, and _. This field can be used to show channel subtype, such as connect:Guide.  To set contact expiry, a ValueMap must be specified containing the integer number of minutes the contact will be active for before expiring, with SegmentAttributes like {  "connect:ContactExpiry": {"ValueMap" : { "ExpiryDuration": { "ValueInteger":135}}}}.
    ///   - logger: Logger use during operation
    @inlinable
    public func startEmailContact(
        additionalRecipients: InboundAdditionalRecipients? = nil,
        attachments: [EmailAttachment]? = nil,
        attributes: [String: String]? = nil,
        clientToken: String? = StartEmailContactRequest.idempotencyToken(),
        contactFlowId: String? = nil,
        description: String? = nil,
        destinationEmailAddress: String,
        emailMessage: InboundEmailContent,
        fromEmailAddress: EmailAddressInfo,
        instanceId: String,
        name: String? = nil,
        references: [String: Reference]? = nil,
        relatedContactId: String? = nil,
        segmentAttributes: [String: SegmentAttributeValue]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartEmailContactResponse {
        let input = StartEmailContactRequest(
            additionalRecipients: additionalRecipients, 
            attachments: attachments, 
            attributes: attributes, 
            clientToken: clientToken, 
            contactFlowId: contactFlowId, 
            description: description, 
            destinationEmailAddress: destinationEmailAddress, 
            emailMessage: emailMessage, 
            fromEmailAddress: fromEmailAddress, 
            instanceId: instanceId, 
            name: name, 
            references: references, 
            relatedContactId: relatedContactId, 
            segmentAttributes: segmentAttributes
        )
        return try await self.startEmailContact(input, logger: logger)
    }

    /// Initiates a new outbound SMS contact to a customer. Response of this API provides the ContactId of the outbound SMS contact created.  SourceEndpoint only supports Endpoints with CONNECT_PHONENUMBER_ARN as Type and DestinationEndpoint only supports Endpoints with TELEPHONE_NUMBER as Type. ContactFlowId initiates the flow to manage the new SMS contact created. This API can be used to initiate outbound SMS contacts for an agent, or it can also deflect an ongoing contact to an outbound SMS contact by using the StartOutboundChatContact Flow Action. For more information about using SMS in Amazon Connect, see the following topics in the Amazon Connect Administrator Guide:    Set up SMS messaging     Request an SMS-enabled phone number through AWS End User Messaging SMS
    @Sendable
    @inlinable
    public func startOutboundChatContact(_ input: StartOutboundChatContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartOutboundChatContactResponse {
        try await self.client.execute(
            operation: "StartOutboundChatContact", 
            path: "/contact/outbound-chat", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Initiates a new outbound SMS contact to a customer. Response of this API provides the ContactId of the outbound SMS contact created.  SourceEndpoint only supports Endpoints with CONNECT_PHONENUMBER_ARN as Type and DestinationEndpoint only supports Endpoints with TELEPHONE_NUMBER as Type. ContactFlowId initiates the flow to manage the new SMS contact created. This API can be used to initiate outbound SMS contacts for an agent, or it can also deflect an ongoing contact to an outbound SMS contact by using the StartOutboundChatContact Flow Action. For more information about using SMS in Amazon Connect, see the following topics in the Amazon Connect Administrator Guide:    Set up SMS messaging     Request an SMS-enabled phone number through AWS End User Messaging SMS
    ///
    /// Parameters:
    ///   - attributes: A custom key-value pair using an attribute map. The attributes are standard Amazon Connect attributes, and can be accessed in flows just like any other contact attributes.
    ///   - chatDurationInMinutes: The total duration of the newly started chat session. If not specified, the chat session duration defaults to 25 hour. The minimum configurable time is 60 minutes. The maximum configurable time is 10,080 minutes (7 days).
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the AWS SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs. The token is valid for 7 days after creation. If a contact is already started, the contact ID is returned.
    ///   - contactFlowId: The identifier of the flow for the call. To see the ContactFlowId in the Amazon Connect console user interface, on the navigation menu go to Routing, Contact Flows. Choose the flow. On the flow page, under the name of the flow, choose Show additional flow information. The ContactFlowId is the last part of the ARN, shown here in bold:   arn:aws:connect:us-west-2:xxxxxxxxxxxx:instance/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/contact-flow/123ec456-a007-89c0-1234-xxxxxxxxxxxx
    ///   - destinationEndpoint: 
    ///   - initialSystemMessage: 
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - participantDetails: 
    ///   - relatedContactId: The unique identifier for an Amazon Connect contact. This identifier is related to the contact starting.
    ///   - segmentAttributes: A set of system defined key-value pairs stored on individual contact segments using an attribute map. The attributes are standard Amazon Connect attributes. They can be accessed in flows.   Attribute keys can include only alphanumeric, -, and _.   This field can be used to show channel subtype, such as connect:Guide and connect:SMS.
    ///   - sourceEndpoint: 
    ///   - supportedMessagingContentTypes: The supported chat message content types. Supported types are:    text/plain     text/markdown     application/json, application/vnd.amazonaws.connect.message.interactive     application/vnd.amazonaws.connect.message.interactive.response    Content types must always contain text/plain. You can then put any other supported type in the list. For example, all the following lists are valid because they contain text/plain:    [text/plain, text/markdown, application/json]     [text/markdown, text/plain]     [text/plain, application/json, application/vnd.amazonaws.connect.message.interactive.response]
    ///   - logger: Logger use during operation
    @inlinable
    public func startOutboundChatContact(
        attributes: [String: String]? = nil,
        chatDurationInMinutes: Int? = nil,
        clientToken: String? = StartOutboundChatContactRequest.idempotencyToken(),
        contactFlowId: String,
        destinationEndpoint: Endpoint,
        initialSystemMessage: ChatMessage? = nil,
        instanceId: String,
        participantDetails: ParticipantDetails? = nil,
        relatedContactId: String? = nil,
        segmentAttributes: [String: SegmentAttributeValue],
        sourceEndpoint: Endpoint,
        supportedMessagingContentTypes: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartOutboundChatContactResponse {
        let input = StartOutboundChatContactRequest(
            attributes: attributes, 
            chatDurationInMinutes: chatDurationInMinutes, 
            clientToken: clientToken, 
            contactFlowId: contactFlowId, 
            destinationEndpoint: destinationEndpoint, 
            initialSystemMessage: initialSystemMessage, 
            instanceId: instanceId, 
            participantDetails: participantDetails, 
            relatedContactId: relatedContactId, 
            segmentAttributes: segmentAttributes, 
            sourceEndpoint: sourceEndpoint, 
            supportedMessagingContentTypes: supportedMessagingContentTypes
        )
        return try await self.startOutboundChatContact(input, logger: logger)
    }

    /// Initiates a flow to send an agent reply or outbound email contact (created from the CreateContact API) to a customer.
    @Sendable
    @inlinable
    public func startOutboundEmailContact(_ input: StartOutboundEmailContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartOutboundEmailContactResponse {
        try await self.client.execute(
            operation: "StartOutboundEmailContact", 
            path: "/contact/outbound-email", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Initiates a flow to send an agent reply or outbound email contact (created from the CreateContact API) to a customer.
    ///
    /// Parameters:
    ///   - additionalRecipients: The additional recipients address of email in CC.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - contactId: The identifier of the contact in this instance of Amazon Connect.
    ///   - destinationEmailAddress: The email address of the customer.
    ///   - emailMessage: The email message body to be sent to the newly created email.
    ///   - fromEmailAddress: The email address associated with the Amazon Connect instance.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func startOutboundEmailContact(
        additionalRecipients: OutboundAdditionalRecipients? = nil,
        clientToken: String? = StartOutboundEmailContactRequest.idempotencyToken(),
        contactId: String,
        destinationEmailAddress: EmailAddressInfo,
        emailMessage: OutboundEmailContent,
        fromEmailAddress: EmailAddressInfo? = nil,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartOutboundEmailContactResponse {
        let input = StartOutboundEmailContactRequest(
            additionalRecipients: additionalRecipients, 
            clientToken: clientToken, 
            contactId: contactId, 
            destinationEmailAddress: destinationEmailAddress, 
            emailMessage: emailMessage, 
            fromEmailAddress: fromEmailAddress, 
            instanceId: instanceId
        )
        return try await self.startOutboundEmailContact(input, logger: logger)
    }

    /// Places an outbound call to a contact, and then initiates the flow. It performs the actions in the flow that's specified (in ContactFlowId). Agents do not initiate the outbound API, which means that they do not dial the contact. If the flow places an outbound call to a contact, and then puts the contact in queue, the call is then routed to the agent, like any other inbound case. There is a 60-second dialing timeout for this operation. If the call is not connected after 60 seconds, it fails.  UK numbers with a 447 prefix are not allowed by default. Before you can dial these UK mobile numbers, you must submit a service quota increase request. For more information, see Amazon Connect Service Quotas in the Amazon Connect Administrator Guide.    Campaign calls are not allowed by default. Before you can make a call with TrafficType = CAMPAIGN, you must submit a service quota increase request to the quota Amazon Connect campaigns.
    @Sendable
    @inlinable
    public func startOutboundVoiceContact(_ input: StartOutboundVoiceContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartOutboundVoiceContactResponse {
        try await self.client.execute(
            operation: "StartOutboundVoiceContact", 
            path: "/contact/outbound-voice", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Places an outbound call to a contact, and then initiates the flow. It performs the actions in the flow that's specified (in ContactFlowId). Agents do not initiate the outbound API, which means that they do not dial the contact. If the flow places an outbound call to a contact, and then puts the contact in queue, the call is then routed to the agent, like any other inbound case. There is a 60-second dialing timeout for this operation. If the call is not connected after 60 seconds, it fails.  UK numbers with a 447 prefix are not allowed by default. Before you can dial these UK mobile numbers, you must submit a service quota increase request. For more information, see Amazon Connect Service Quotas in the Amazon Connect Administrator Guide.    Campaign calls are not allowed by default. Before you can make a call with TrafficType = CAMPAIGN, you must submit a service quota increase request to the quota Amazon Connect campaigns.
    ///
    /// Parameters:
    ///   - answerMachineDetectionConfig: Configuration of the answering machine detection for this outbound call.
    ///   - attributes: A custom key-value pair using an attribute map. The attributes are standard Amazon Connect attributes, and can be accessed in flows just like any other contact attributes. There can be up to 32,768 UTF-8 bytes across all key-value pairs per contact. Attribute keys can include only alphanumeric, dash, and underscore characters.
    ///   - campaignId: The campaign identifier of the outbound communication.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs. The token is valid for 7 days after creation. If a contact is already started, the contact ID is returned.
    ///   - contactFlowId: The identifier of the flow for the outbound call. To see the ContactFlowId in the Amazon Connect admin website, on the navigation menu go to Routing, Contact Flows. Choose the flow. On the flow page, under the name of the flow, choose Show additional flow information. The ContactFlowId is the last part of the ARN, shown here in bold:  arn:aws:connect:us-west-2:xxxxxxxxxxxx:instance/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/contact-flow/846ec553-a005-41c0-8341-xxxxxxxxxxxx
    ///   - description: A description of the voice contact that appears in the agent's snapshot in the CCP logs. For more information about CCP logs, see Download and review CCP logs in the Amazon Connect Administrator Guide.
    ///   - destinationPhoneNumber: The phone number of the customer, in E.164 format.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of a voice contact that is shown to an agent in the Contact Control Panel (CCP).
    ///   - queueId: The queue for the call. If you specify a queue, the phone displayed for caller ID is the phone number specified in the queue. If you do not specify a queue, the queue defined in the flow is used. If you do not specify a queue, you must specify a source phone number.
    ///   - references: A formatted URL that is shown to an agent in the Contact Control Panel (CCP). Contacts can have the following reference types at the time of creation: URL | NUMBER | STRING | DATE | EMAIL. ATTACHMENT is not a supported reference type during voice contact creation.
    ///   - relatedContactId: The contactId that is related to this contact. Linking voice, task, or chat by using RelatedContactID copies over contact attributes from the related contact to the new contact. All updates to user-defined attributes in the new contact are limited to the individual contact ID. There are no limits to the number of contacts that can be linked by using RelatedContactId.
    ///   - sourcePhoneNumber: The phone number associated with the Amazon Connect instance, in E.164 format. If you do not specify a source phone number, you must specify a queue.
    ///   - trafficType: Denotes the class of traffic. Calls with different traffic types are handled differently by Amazon Connect. The default value is GENERAL. Use CAMPAIGN if EnableAnswerMachineDetection is set to true. For all other cases, use GENERAL.
    ///   - logger: Logger use during operation
    @inlinable
    public func startOutboundVoiceContact(
        answerMachineDetectionConfig: AnswerMachineDetectionConfig? = nil,
        attributes: [String: String]? = nil,
        campaignId: String? = nil,
        clientToken: String? = StartOutboundVoiceContactRequest.idempotencyToken(),
        contactFlowId: String,
        description: String? = nil,
        destinationPhoneNumber: String,
        instanceId: String,
        name: String? = nil,
        queueId: String? = nil,
        references: [String: Reference]? = nil,
        relatedContactId: String? = nil,
        sourcePhoneNumber: String? = nil,
        trafficType: TrafficType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartOutboundVoiceContactResponse {
        let input = StartOutboundVoiceContactRequest(
            answerMachineDetectionConfig: answerMachineDetectionConfig, 
            attributes: attributes, 
            campaignId: campaignId, 
            clientToken: clientToken, 
            contactFlowId: contactFlowId, 
            description: description, 
            destinationPhoneNumber: destinationPhoneNumber, 
            instanceId: instanceId, 
            name: name, 
            queueId: queueId, 
            references: references, 
            relatedContactId: relatedContactId, 
            sourcePhoneNumber: sourcePhoneNumber, 
            trafficType: trafficType
        )
        return try await self.startOutboundVoiceContact(input, logger: logger)
    }

    /// Starts screen sharing for a contact. For more information about screen sharing, see Set up in-app, web, video calling, and screen sharing capabilities in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func startScreenSharing(_ input: StartScreenSharingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartScreenSharingResponse {
        try await self.client.execute(
            operation: "StartScreenSharing", 
            path: "/contact/screen-sharing", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts screen sharing for a contact. For more information about screen sharing, see Set up in-app, web, video calling, and screen sharing capabilities in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - contactId: The identifier of the contact in this instance of Amazon Connect.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func startScreenSharing(
        clientToken: String? = StartScreenSharingRequest.idempotencyToken(),
        contactId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartScreenSharingResponse {
        let input = StartScreenSharingRequest(
            clientToken: clientToken, 
            contactId: contactId, 
            instanceId: instanceId
        )
        return try await self.startScreenSharing(input, logger: logger)
    }

    /// Initiates a flow to start a new task contact. For more information about task contacts, see Concepts: Tasks in Amazon Connect in the Amazon Connect Administrator Guide.  When using PreviousContactId and RelatedContactId input parameters, note the following:    PreviousContactId    Any updates to user-defined task contact attributes on any contact linked through the same PreviousContactId will affect every contact in the chain.   There can be a maximum of 12 linked task contacts in a chain. That is, 12 task contacts can be created that share the same PreviousContactId.      RelatedContactId    Copies contact attributes from the related task contact to the new contact.   Any update on attributes in a new task contact does not update attributes on previous contact.   There’s no limit on the number of task contacts that can be created that use the same RelatedContactId.     In addition, when calling StartTaskContact include only one of these parameters: ContactFlowID, QuickConnectID, or TaskTemplateID. Only one parameter is required as long as the task template has a flow configured to run it. If more than one parameter is specified, or only the TaskTemplateID is specified but it does not have a flow configured, the request returns an error because Amazon Connect cannot identify the unique flow to run when the task is created. A ServiceQuotaExceededException occurs when the number of open tasks exceeds the active tasks quota or there are already 12 tasks referencing the same PreviousContactId. For more information about service quotas for task contacts, see Amazon Connect service quotas in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func startTaskContact(_ input: StartTaskContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartTaskContactResponse {
        try await self.client.execute(
            operation: "StartTaskContact", 
            path: "/contact/task", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Initiates a flow to start a new task contact. For more information about task contacts, see Concepts: Tasks in Amazon Connect in the Amazon Connect Administrator Guide.  When using PreviousContactId and RelatedContactId input parameters, note the following:    PreviousContactId    Any updates to user-defined task contact attributes on any contact linked through the same PreviousContactId will affect every contact in the chain.   There can be a maximum of 12 linked task contacts in a chain. That is, 12 task contacts can be created that share the same PreviousContactId.      RelatedContactId    Copies contact attributes from the related task contact to the new contact.   Any update on attributes in a new task contact does not update attributes on previous contact.   There’s no limit on the number of task contacts that can be created that use the same RelatedContactId.     In addition, when calling StartTaskContact include only one of these parameters: ContactFlowID, QuickConnectID, or TaskTemplateID. Only one parameter is required as long as the task template has a flow configured to run it. If more than one parameter is specified, or only the TaskTemplateID is specified but it does not have a flow configured, the request returns an error because Amazon Connect cannot identify the unique flow to run when the task is created. A ServiceQuotaExceededException occurs when the number of open tasks exceeds the active tasks quota or there are already 12 tasks referencing the same PreviousContactId. For more information about service quotas for task contacts, see Amazon Connect service quotas in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - attributes: A custom key-value pair using an attribute map. The attributes are standard Amazon Connect attributes, and can be accessed in flows just like any other contact attributes. There can be up to 32,768 UTF-8 bytes across all key-value pairs per contact. Attribute keys can include only alphanumeric, dash, and underscore characters.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - contactFlowId: The identifier of the flow for initiating the tasks. To see the ContactFlowId in the Amazon Connect admin website, on the navigation menu go to Routing, Flows. Choose the flow. On the flow page, under the name of the flow, choose Show additional flow information. The ContactFlowId is the last part of the ARN, shown here in bold:  arn:aws:connect:us-west-2:xxxxxxxxxxxx:instance/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/contact-flow/846ec553-a005-41c0-8341-xxxxxxxxxxxx
    ///   - description: A description of the task that is shown to an agent in the Contact Control Panel (CCP).
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of a task that is shown to an agent in the Contact Control Panel (CCP).
    ///   - previousContactId: The identifier of the previous chat, voice, or task contact. Any updates to user-defined attributes to task contacts linked using the same PreviousContactID will affect every contact in the chain. There can be a maximum of 12 linked task contacts in a chain.
    ///   - quickConnectId: The identifier for the quick connect. Tasks that are created by using QuickConnectId will use the flow that is defined on agent or queue quick connect. For more information about quick connects, see Create quick connects.
    ///   - references: A formatted URL that is shown to an agent in the Contact Control Panel (CCP). Tasks can have the following reference types at the time of creation: URL | NUMBER | STRING | DATE | EMAIL. ATTACHMENT is not a supported reference type during task creation.
    ///   - relatedContactId: The contactId that is related to this contact. Linking tasks together by using RelatedContactID copies over contact attributes from the related task contact to the new task contact. All updates to user-defined attributes in the new task contact are limited to the individual contact ID, unlike what happens when tasks are linked by using PreviousContactID. There are no limits to the number of contacts that can be linked by using RelatedContactId.
    ///   - scheduledTime: The timestamp, in Unix Epoch seconds format, at which to start running the inbound flow. The scheduled time cannot be in the past. It must be within up to 6 days in future.
    ///   - segmentAttributes: A set of system defined key-value pairs stored on individual contact segments (unique contact ID) using an attribute map. The attributes are standard Amazon Connect attributes. They can be accessed in flows. Attribute keys can include only alphanumeric, -, and _. This field can be used to set Contact Expiry as a duration in minutes and set a UserId for the User who created a task.  To set contact expiry, a ValueMap must be specified containing the integer number of minutes the contact will be active for before expiring, with SegmentAttributes like {  "connect:ContactExpiry": {"ValueMap" : { "ExpiryDuration": { "ValueInteger": 135}}}}.  To set the created by user, a valid AgentResourceId must be supplied, with SegmentAttributes like { "connect:CreatedByUser" { "ValueString": "arn:aws:connect:us-west-2:xxxxxxxxxxxx:instance/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/agent/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"}}}.
    ///   - taskTemplateId: A unique identifier for the task template. For more information about task templates, see Create task templates in the Amazon Connect Administrator Guide.
    ///   - logger: Logger use during operation
    @inlinable
    public func startTaskContact(
        attributes: [String: String]? = nil,
        clientToken: String? = StartTaskContactRequest.idempotencyToken(),
        contactFlowId: String? = nil,
        description: String? = nil,
        instanceId: String,
        name: String,
        previousContactId: String? = nil,
        quickConnectId: String? = nil,
        references: [String: Reference]? = nil,
        relatedContactId: String? = nil,
        scheduledTime: Date? = nil,
        segmentAttributes: [String: SegmentAttributeValue]? = nil,
        taskTemplateId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartTaskContactResponse {
        let input = StartTaskContactRequest(
            attributes: attributes, 
            clientToken: clientToken, 
            contactFlowId: contactFlowId, 
            description: description, 
            instanceId: instanceId, 
            name: name, 
            previousContactId: previousContactId, 
            quickConnectId: quickConnectId, 
            references: references, 
            relatedContactId: relatedContactId, 
            scheduledTime: scheduledTime, 
            segmentAttributes: segmentAttributes, 
            taskTemplateId: taskTemplateId
        )
        return try await self.startTaskContact(input, logger: logger)
    }

    /// Places an inbound in-app, web, or video call to a contact, and then initiates the flow. It performs the actions in the flow that are specified (in ContactFlowId) and present in the Amazon Connect instance (specified as InstanceId).
    @Sendable
    @inlinable
    public func startWebRTCContact(_ input: StartWebRTCContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartWebRTCContactResponse {
        try await self.client.execute(
            operation: "StartWebRTCContact", 
            path: "/contact/webrtc", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Places an inbound in-app, web, or video call to a contact, and then initiates the flow. It performs the actions in the flow that are specified (in ContactFlowId) and present in the Amazon Connect instance (specified as InstanceId).
    ///
    /// Parameters:
    ///   - allowedCapabilities: Information about the video sharing capabilities of the participants (customer, agent).
    ///   - attributes: A custom key-value pair using an attribute map. The attributes are standard Amazon Connect attributes, and can be accessed in flows just like any other contact attributes. There can be up to 32,768 UTF-8 bytes across all key-value pairs per contact. Attribute keys can include only alphanumeric, -, and _ characters.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs. The token is valid for 7 days after creation. If a contact is already started, the contact ID is returned.
    ///   - contactFlowId: The identifier of the flow for the call. To see the ContactFlowId in the Amazon Connect admin website, on the navigation menu go to Routing, Flows. Choose the flow. On the flow page, under the name of the flow, choose Show additional flow information. The ContactFlowId is the last part of the ARN, shown here in bold:  arn:aws:connect:us-west-2:xxxxxxxxxxxx:instance/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/contact-flow/846ec553-a005-41c0-8341-xxxxxxxxxxxx
    ///   - description: A description of the task that is shown to an agent in the Contact Control Panel (CCP).
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - participantDetails: 
    ///   - references: A formatted URL that is shown to an agent in the Contact Control Panel (CCP). Tasks can have the following reference types at the time of creation: URL | NUMBER | STRING | DATE | EMAIL. ATTACHMENT is not a supported reference type during task creation.
    ///   - relatedContactId: The unique identifier for an Amazon Connect contact. This identifier is related to the contact starting.
    ///   - logger: Logger use during operation
    @inlinable
    public func startWebRTCContact(
        allowedCapabilities: AllowedCapabilities? = nil,
        attributes: [String: String]? = nil,
        clientToken: String? = StartWebRTCContactRequest.idempotencyToken(),
        contactFlowId: String,
        description: String? = nil,
        instanceId: String,
        participantDetails: ParticipantDetails,
        references: [String: Reference]? = nil,
        relatedContactId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartWebRTCContactResponse {
        let input = StartWebRTCContactRequest(
            allowedCapabilities: allowedCapabilities, 
            attributes: attributes, 
            clientToken: clientToken, 
            contactFlowId: contactFlowId, 
            description: description, 
            instanceId: instanceId, 
            participantDetails: participantDetails, 
            references: references, 
            relatedContactId: relatedContactId
        )
        return try await self.startWebRTCContact(input, logger: logger)
    }

    /// Ends the specified contact. Use this API to stop queued callbacks. It does not work for voice contacts that use the following initiation methods:   DISCONNECT   TRANSFER   QUEUE_TRANSFER   EXTERNAL_OUTBOUND   MONITOR   Chat and task contacts can be terminated in any state, regardless of initiation method.
    @Sendable
    @inlinable
    public func stopContact(_ input: StopContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StopContactResponse {
        try await self.client.execute(
            operation: "StopContact", 
            path: "/contact/stop", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Ends the specified contact. Use this API to stop queued callbacks. It does not work for voice contacts that use the following initiation methods:   DISCONNECT   TRANSFER   QUEUE_TRANSFER   EXTERNAL_OUTBOUND   MONITOR   Chat and task contacts can be terminated in any state, regardless of initiation method.
    ///
    /// Parameters:
    ///   - contactId: The ID of the contact.
    ///   - disconnectReason: The reason a contact can be disconnected. Only Amazon Connect outbound campaigns can provide this field.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func stopContact(
        contactId: String,
        disconnectReason: DisconnectReason? = nil,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StopContactResponse {
        let input = StopContactRequest(
            contactId: contactId, 
            disconnectReason: disconnectReason, 
            instanceId: instanceId
        )
        return try await self.stopContact(input, logger: logger)
    }

    /// Stops recording a call when a contact is being recorded. StopContactRecording is a one-time action. If you use StopContactRecording to stop recording an ongoing call, you can't use StartContactRecording to restart it. For scenarios where the recording has started and you want to suspend it for sensitive information (for example, to collect a credit card number), and then restart it, use SuspendContactRecording and ResumeContactRecording. Only voice recordings are supported at this time.
    @Sendable
    @inlinable
    public func stopContactRecording(_ input: StopContactRecordingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StopContactRecordingResponse {
        try await self.client.execute(
            operation: "StopContactRecording", 
            path: "/contact/stop-recording", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Stops recording a call when a contact is being recorded. StopContactRecording is a one-time action. If you use StopContactRecording to stop recording an ongoing call, you can't use StartContactRecording to restart it. For scenarios where the recording has started and you want to suspend it for sensitive information (for example, to collect a credit card number), and then restart it, use SuspendContactRecording and ResumeContactRecording. Only voice recordings are supported at this time.
    ///
    /// Parameters:
    ///   - contactId: The identifier of the contact.
    ///   - contactRecordingType: The type of recording being operated on.
    ///   - initialContactId: The identifier of the contact. This is the identifier of the contact associated with the first interaction with the contact center.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func stopContactRecording(
        contactId: String,
        contactRecordingType: ContactRecordingType? = nil,
        initialContactId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StopContactRecordingResponse {
        let input = StopContactRecordingRequest(
            contactId: contactId, 
            contactRecordingType: contactRecordingType, 
            initialContactId: initialContactId, 
            instanceId: instanceId
        )
        return try await self.stopContactRecording(input, logger: logger)
    }

    ///  Ends message streaming on a specified contact. To restart message streaming on that contact, call the StartContactStreaming API.
    @Sendable
    @inlinable
    public func stopContactStreaming(_ input: StopContactStreamingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StopContactStreamingResponse {
        try await self.client.execute(
            operation: "StopContactStreaming", 
            path: "/contact/stop-streaming", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Ends message streaming on a specified contact. To restart message streaming on that contact, call the StartContactStreaming API.
    ///
    /// Parameters:
    ///   - contactId: The identifier of the contact. This is the identifier of the contact that is associated with the first interaction with the contact center.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - streamingId: The identifier of the streaming configuration enabled.
    ///   - logger: Logger use during operation
    @inlinable
    public func stopContactStreaming(
        contactId: String,
        instanceId: String,
        streamingId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StopContactStreamingResponse {
        let input = StopContactStreamingRequest(
            contactId: contactId, 
            instanceId: instanceId, 
            streamingId: streamingId
        )
        return try await self.stopContactStreaming(input, logger: logger)
    }

    /// Submits a contact evaluation in the specified Amazon Connect instance. Answers included in the request are merged with existing answers for the given evaluation. If no answers or notes are passed, the evaluation is submitted with the existing answers and notes. You can delete an answer or note by passing an empty object ({}) to the question identifier.  If a contact evaluation is already in submitted state, this operation will trigger a resubmission.
    @Sendable
    @inlinable
    public func submitContactEvaluation(_ input: SubmitContactEvaluationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SubmitContactEvaluationResponse {
        try await self.client.execute(
            operation: "SubmitContactEvaluation", 
            path: "/contact-evaluations/{InstanceId}/{EvaluationId}/submit", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Submits a contact evaluation in the specified Amazon Connect instance. Answers included in the request are merged with existing answers for the given evaluation. If no answers or notes are passed, the evaluation is submitted with the existing answers and notes. You can delete an answer or note by passing an empty object ({}) to the question identifier.  If a contact evaluation is already in submitted state, this operation will trigger a resubmission.
    ///
    /// Parameters:
    ///   - answers: A map of question identifiers to answer value.
    ///   - evaluationId: A unique identifier for the contact evaluation.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - notes: A map of question identifiers to note value.
    ///   - logger: Logger use during operation
    @inlinable
    public func submitContactEvaluation(
        answers: [String: EvaluationAnswerInput]? = nil,
        evaluationId: String,
        instanceId: String,
        notes: [String: EvaluationNote]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SubmitContactEvaluationResponse {
        let input = SubmitContactEvaluationRequest(
            answers: answers, 
            evaluationId: evaluationId, 
            instanceId: instanceId, 
            notes: notes
        )
        return try await self.submitContactEvaluation(input, logger: logger)
    }

    /// When a contact is being recorded, this API suspends recording whatever is selected in the flow configuration: call (IVR or agent), screen, or both. If only call recording or only screen recording is enabled, then it would be suspended. For example, you might suspend the screen recording while collecting sensitive information, such as a credit card number. Then use ResumeContactRecording to restart recording the screen. The period of time that the recording is suspended is filled with silence in the final recording.  Voice (IVR, agent) and screen recordings are supported.
    @Sendable
    @inlinable
    public func suspendContactRecording(_ input: SuspendContactRecordingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SuspendContactRecordingResponse {
        try await self.client.execute(
            operation: "SuspendContactRecording", 
            path: "/contact/suspend-recording", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// When a contact is being recorded, this API suspends recording whatever is selected in the flow configuration: call (IVR or agent), screen, or both. If only call recording or only screen recording is enabled, then it would be suspended. For example, you might suspend the screen recording while collecting sensitive information, such as a credit card number. Then use ResumeContactRecording to restart recording the screen. The period of time that the recording is suspended is filled with silence in the final recording.  Voice (IVR, agent) and screen recordings are supported.
    ///
    /// Parameters:
    ///   - contactId: The identifier of the contact.
    ///   - contactRecordingType: The type of recording being operated on.
    ///   - initialContactId: The identifier of the contact. This is the identifier of the contact associated with the first interaction with the contact center.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func suspendContactRecording(
        contactId: String,
        contactRecordingType: ContactRecordingType? = nil,
        initialContactId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SuspendContactRecordingResponse {
        let input = SuspendContactRecordingRequest(
            contactId: contactId, 
            contactRecordingType: contactRecordingType, 
            initialContactId: initialContactId, 
            instanceId: instanceId
        )
        return try await self.suspendContactRecording(input, logger: logger)
    }

    /// Adds the specified tags to the contact resource. For more information about this API is used, see Set up granular billing for a detailed view of your Amazon Connect usage.
    @Sendable
    @inlinable
    public func tagContact(_ input: TagContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagContactResponse {
        try await self.client.execute(
            operation: "TagContact", 
            path: "/contact/tags", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds the specified tags to the contact resource. For more information about this API is used, see Set up granular billing for a detailed view of your Amazon Connect usage.
    ///
    /// Parameters:
    ///   - contactId: The identifier of the contact in this instance of Amazon Connect.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - tags: The tags to be assigned to the contact resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.  Authorization is not supported by this tag.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagContact(
        contactId: String,
        instanceId: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagContactResponse {
        let input = TagContactRequest(
            contactId: contactId, 
            instanceId: instanceId, 
            tags: tags
        )
        return try await self.tagContact(input, logger: logger)
    }

    /// Adds the specified tags to the specified resource. Some of the supported resource types are agents, routing profiles, queues, quick connects, flows, agent statuses, hours of operation, phone numbers, security profiles, and task templates. For a complete list, see Tagging resources in Amazon Connect. For sample policies that use tags, see Amazon Connect Identity-Based Policy Examples in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds the specified tags to the specified resource. Some of the supported resource types are agents, routing profiles, queues, quick connects, flows, agent statuses, hours of operation, phone numbers, security profiles, and task templates. For a complete list, see Tagging resources in Amazon Connect. For sample policies that use tags, see Amazon Connect Identity-Based Policy Examples in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tags: The tags used to organize, track, or control access for this resource. For example, { "Tags": {"key1":"value1", "key2":"value2"} }.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Transfers TASK or EMAIL contacts from one agent or queue to another agent or queue at any point after a contact is created. You can transfer a contact to another queue by providing the flow which orchestrates the contact to the destination queue. This gives you more control over contact handling and helps you adhere to the service level agreement (SLA) guaranteed to your customers. Note the following requirements:   Transfer is only supported for TASK and EMAIL contacts.   Do not use both QueueId and UserId in the same call.   The following flow types are supported: Inbound flow, Transfer to agent flow, and Transfer to queue flow.   The TransferContact API can be called only on active contacts.   A contact cannot be transferred more than 11 times.
    @Sendable
    @inlinable
    public func transferContact(_ input: TransferContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TransferContactResponse {
        try await self.client.execute(
            operation: "TransferContact", 
            path: "/contact/transfer", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Transfers TASK or EMAIL contacts from one agent or queue to another agent or queue at any point after a contact is created. You can transfer a contact to another queue by providing the flow which orchestrates the contact to the destination queue. This gives you more control over contact handling and helps you adhere to the service level agreement (SLA) guaranteed to your customers. Note the following requirements:   Transfer is only supported for TASK and EMAIL contacts.   Do not use both QueueId and UserId in the same call.   The following flow types are supported: Inbound flow, Transfer to agent flow, and Transfer to queue flow.   The TransferContact API can be called only on active contacts.   A contact cannot be transferred more than 11 times.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - contactFlowId: The identifier of the flow.
    ///   - contactId: The identifier of the contact in this instance of Amazon Connect.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - queueId: The identifier for the queue.
    ///   - userId: The identifier for the user. This can be the ID or the ARN of the user.
    ///   - logger: Logger use during operation
    @inlinable
    public func transferContact(
        clientToken: String? = TransferContactRequest.idempotencyToken(),
        contactFlowId: String,
        contactId: String,
        instanceId: String,
        queueId: String? = nil,
        userId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TransferContactResponse {
        let input = TransferContactRequest(
            clientToken: clientToken, 
            contactFlowId: contactFlowId, 
            contactId: contactId, 
            instanceId: instanceId, 
            queueId: queueId, 
            userId: userId
        )
        return try await self.transferContact(input, logger: logger)
    }

    /// Removes the specified tags from the contact resource. For more information about this API is used, see Set up granular billing for a detailed view of your Amazon Connect usage.
    @Sendable
    @inlinable
    public func untagContact(_ input: UntagContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagContactResponse {
        try await self.client.execute(
            operation: "UntagContact", 
            path: "/contact/tags/{InstanceId}/{ContactId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the specified tags from the contact resource. For more information about this API is used, see Set up granular billing for a detailed view of your Amazon Connect usage.
    ///
    /// Parameters:
    ///   - contactId: The identifier of the contact in this instance of Amazon Connect.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - tagKeys: A list of tag keys. Existing tags on the contact whose keys are members of this list will be removed.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagContact(
        contactId: String,
        instanceId: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagContactResponse {
        let input = UntagContactRequest(
            contactId: contactId, 
            instanceId: instanceId, 
            tagKeys: tagKeys
        )
        return try await self.untagContact(input, logger: logger)
    }

    /// Removes the specified tags from the specified resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the specified tags from the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tagKeys: The tag keys.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Updates agent status.
    @Sendable
    @inlinable
    public func updateAgentStatus(_ input: UpdateAgentStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateAgentStatus", 
            path: "/agent-status/{InstanceId}/{AgentStatusId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Updates agent status.
    ///
    /// Parameters:
    ///   - agentStatusId: The identifier of the agent status.
    ///   - description: The description of the agent status.
    ///   - displayOrder: The display order of the agent status.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the agent status.
    ///   - resetOrderNumber: A number indicating the reset order of the agent status.
    ///   - state: The state of the agent status.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAgentStatus(
        agentStatusId: String,
        description: String? = nil,
        displayOrder: Int? = nil,
        instanceId: String,
        name: String? = nil,
        resetOrderNumber: Bool? = nil,
        state: AgentStatusState? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateAgentStatusRequest(
            agentStatusId: agentStatusId, 
            description: description, 
            displayOrder: displayOrder, 
            instanceId: instanceId, 
            name: name, 
            resetOrderNumber: resetOrderNumber, 
            state: state
        )
        return try await self.updateAgentStatus(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. To
    /// request access to this API, contact Amazon Web ServicesSupport. Updates the selected authentication profile.
    @Sendable
    @inlinable
    public func updateAuthenticationProfile(_ input: UpdateAuthenticationProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateAuthenticationProfile", 
            path: "/authentication-profiles/{InstanceId}/{AuthenticationProfileId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. To
    /// request access to this API, contact Amazon Web ServicesSupport. Updates the selected authentication profile.
    ///
    /// Parameters:
    ///   - allowedIps: A list of IP address range strings that are allowed to access the instance. For more information on how to configure IP addresses, seeConfigure session timeouts in the Amazon Connect Administrator Guide.
    ///   - authenticationProfileId: A unique identifier for the authentication profile.
    ///   - blockedIps: A list of IP address range strings that are blocked from accessing the instance. For more information on how to configure IP addresses, For more information on how to configure IP addresses, see Configure IP-based access control in the Amazon Connect Administrator Guide.
    ///   - description: The description for the authentication profile.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name for the authentication profile.
    ///   - periodicSessionDuration: The short lived session duration configuration for users logged in to Amazon Connect, in minutes. This value determines the maximum possible time before an agent is authenticated. For more information, For more information on how to configure IP addresses, see Configure session timeouts in the Amazon Connect Administrator Guide.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAuthenticationProfile(
        allowedIps: [String]? = nil,
        authenticationProfileId: String,
        blockedIps: [String]? = nil,
        description: String? = nil,
        instanceId: String,
        name: String? = nil,
        periodicSessionDuration: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateAuthenticationProfileRequest(
            allowedIps: allowedIps, 
            authenticationProfileId: authenticationProfileId, 
            blockedIps: blockedIps, 
            description: description, 
            instanceId: instanceId, 
            name: name, 
            periodicSessionDuration: periodicSessionDuration
        )
        return try await self.updateAuthenticationProfile(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Adds or updates user-defined contact information associated with the specified contact. At least one field to be updated must be present in the request.  You can add or update user-defined contact information for both ongoing and completed contacts.
    @Sendable
    @inlinable
    public func updateContact(_ input: UpdateContactRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateContactResponse {
        try await self.client.execute(
            operation: "UpdateContact", 
            path: "/contacts/{InstanceId}/{ContactId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Adds or updates user-defined contact information associated with the specified contact. At least one field to be updated must be present in the request.  You can add or update user-defined contact information for both ongoing and completed contacts.
    ///
    /// Parameters:
    ///   - contactId: The identifier of the contact. This is the identifier of the contact associated with the first interaction with your contact center.
    ///   - customerEndpoint: The endpoint of the customer for which the contact was initiated. For external audio contacts, this is usually the end customer's phone number. This value can only be updated for external audio contacts. For more information, see Amazon Connect Contact Lens integration in the Amazon Connect Administrator Guide.
    ///   - description: The description of the contact.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the contact.
    ///   - queueInfo:  Information about the queue associated with a contact. This parameter can only be updated for external audio contacts. It is used when you integrate third-party systems with Contact Lens for analytics. For more information, see Amazon Connect Contact Lens integration in the  Amazon Connect Administrator Guide.
    ///   - references: Well-formed data on contact, shown to agents on Contact Control Panel (CCP).
    ///   - segmentAttributes: A set of system defined key-value pairs stored on individual contact segments (unique contact ID) using an attribute map. The attributes are standard Amazon Connect attributes. They can be accessed in flows. Attribute keys can include only alphanumeric, -, and _. This field can be used to show channel subtype, such as connect:Guide. Currently Contact Expiry is the only segment attribute which can be updated by using the UpdateContact API.
    ///   - systemEndpoint: External system endpoint for the contact was initiated. For external audio contacts, this is the phone number of the external system such as the contact center. This value can only be updated for external audio contacts. For more information, see Amazon Connect Contact Lens integration in the Amazon Connect Administrator Guide.
    ///   - userInfo: Information about the agent associated with a contact. This parameter can only be updated for external audio contacts. It is used when you integrate third-party systems with Contact Lens for analytics. For more information, see Amazon Connect Contact Lens integration in the  Amazon Connect Administrator Guide.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateContact(
        contactId: String,
        customerEndpoint: Endpoint? = nil,
        description: String? = nil,
        instanceId: String,
        name: String? = nil,
        queueInfo: QueueInfoInput? = nil,
        references: [String: Reference]? = nil,
        segmentAttributes: [String: SegmentAttributeValue]? = nil,
        systemEndpoint: Endpoint? = nil,
        userInfo: UserInfo? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateContactResponse {
        let input = UpdateContactRequest(
            contactId: contactId, 
            customerEndpoint: customerEndpoint, 
            description: description, 
            instanceId: instanceId, 
            name: name, 
            queueInfo: queueInfo, 
            references: references, 
            segmentAttributes: segmentAttributes, 
            systemEndpoint: systemEndpoint, 
            userInfo: userInfo
        )
        return try await self.updateContact(input, logger: logger)
    }

    /// Creates or updates user-defined contact attributes associated with the specified contact. You can create or update user-defined attributes for both ongoing and completed contacts. For example, while the call is active, you can update the customer's name or the reason the customer called. You can add notes about steps that the agent took during the call that display to the next agent that takes the call. You can also update attributes for a contact using data from your CRM application and save the data with the contact in Amazon Connect. You could also flag calls for additional analysis, such as legal review or to identify abusive callers. Contact attributes are available in Amazon Connect for 24 months, and are then deleted. For information about contact record retention and the maximum size of the contact record attributes section, see Feature specifications in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func updateContactAttributes(_ input: UpdateContactAttributesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateContactAttributesResponse {
        try await self.client.execute(
            operation: "UpdateContactAttributes", 
            path: "/contact/attributes", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates or updates user-defined contact attributes associated with the specified contact. You can create or update user-defined attributes for both ongoing and completed contacts. For example, while the call is active, you can update the customer's name or the reason the customer called. You can add notes about steps that the agent took during the call that display to the next agent that takes the call. You can also update attributes for a contact using data from your CRM application and save the data with the contact in Amazon Connect. You could also flag calls for additional analysis, such as legal review or to identify abusive callers. Contact attributes are available in Amazon Connect for 24 months, and are then deleted. For information about contact record retention and the maximum size of the contact record attributes section, see Feature specifications in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - attributes: The Amazon Connect attributes. These attributes can be accessed in flows just like any other contact attributes. You can have up to 32,768 UTF-8 bytes across all attributes for a contact. Attribute keys can include only alphanumeric, dash, and underscore characters. In the Set contact attributes block, when the attributes for a contact exceed 32 KB, the contact is routed down the Error branch of the flow. As a mitigation, consider the following options:   Remove unnecessary attributes by setting their values to empty.   If the attributes are only used in one flow and don't need to be referred to outside of that flow (for example, by a Lambda or another flow), then use flow attributes. This way you aren't needlessly persisting the 32 KB of information from one flow to another. For more information, see Flow block: Set contact attributes in the Amazon Connect Administrator Guide.
    ///   - initialContactId: The identifier of the contact. This is the identifier of the contact associated with the first interaction with the contact center.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateContactAttributes(
        attributes: [String: String],
        initialContactId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateContactAttributesResponse {
        let input = UpdateContactAttributesRequest(
            attributes: attributes, 
            initialContactId: initialContactId, 
            instanceId: instanceId
        )
        return try await self.updateContactAttributes(input, logger: logger)
    }

    /// Updates details about a contact evaluation in the specified Amazon Connect instance. A contact evaluation must be in draft state. Answers included in the request are merged with existing answers for the given evaluation. An answer or note can be deleted by passing an empty object ({}) to the question identifier.
    @Sendable
    @inlinable
    public func updateContactEvaluation(_ input: UpdateContactEvaluationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateContactEvaluationResponse {
        try await self.client.execute(
            operation: "UpdateContactEvaluation", 
            path: "/contact-evaluations/{InstanceId}/{EvaluationId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates details about a contact evaluation in the specified Amazon Connect instance. A contact evaluation must be in draft state. Answers included in the request are merged with existing answers for the given evaluation. An answer or note can be deleted by passing an empty object ({}) to the question identifier.
    ///
    /// Parameters:
    ///   - answers: A map of question identifiers to answer value.
    ///   - evaluationId: A unique identifier for the contact evaluation.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - notes: A map of question identifiers to note value.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateContactEvaluation(
        answers: [String: EvaluationAnswerInput]? = nil,
        evaluationId: String,
        instanceId: String,
        notes: [String: EvaluationNote]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateContactEvaluationResponse {
        let input = UpdateContactEvaluationRequest(
            answers: answers, 
            evaluationId: evaluationId, 
            instanceId: instanceId, 
            notes: notes
        )
        return try await self.updateContactEvaluation(input, logger: logger)
    }

    /// Updates the specified flow. You can also create and update flows using the Amazon Connect Flow language. Use the $SAVED alias in the request to describe the SAVED content of a Flow. For example, arn:aws:.../contact-flow/{id}:$SAVED. After a flow is published, $SAVED needs to be supplied to view saved content that has not been published.
    @Sendable
    @inlinable
    public func updateContactFlowContent(_ input: UpdateContactFlowContentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateContactFlowContentResponse {
        try await self.client.execute(
            operation: "UpdateContactFlowContent", 
            path: "/contact-flows/{InstanceId}/{ContactFlowId}/content", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the specified flow. You can also create and update flows using the Amazon Connect Flow language. Use the $SAVED alias in the request to describe the SAVED content of a Flow. For example, arn:aws:.../contact-flow/{id}:$SAVED. After a flow is published, $SAVED needs to be supplied to view saved content that has not been published.
    ///
    /// Parameters:
    ///   - contactFlowId: The identifier of the flow.
    ///   - content: The JSON string that represents the content of the flow. For an example, see Example flow in Amazon Connect Flow language.  Length Constraints: Minimum length of 1. Maximum length of 256000.
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateContactFlowContent(
        contactFlowId: String,
        content: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateContactFlowContentResponse {
        let input = UpdateContactFlowContentRequest(
            contactFlowId: contactFlowId, 
            content: content, 
            instanceId: instanceId
        )
        return try await self.updateContactFlowContent(input, logger: logger)
    }

    /// Updates metadata about specified flow.
    @Sendable
    @inlinable
    public func updateContactFlowMetadata(_ input: UpdateContactFlowMetadataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateContactFlowMetadataResponse {
        try await self.client.execute(
            operation: "UpdateContactFlowMetadata", 
            path: "/contact-flows/{InstanceId}/{ContactFlowId}/metadata", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates metadata about specified flow.
    ///
    /// Parameters:
    ///   - contactFlowId: The identifier of the flow.
    ///   - contactFlowState: The state of flow.
    ///   - description: The description of the flow.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the flow.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateContactFlowMetadata(
        contactFlowId: String,
        contactFlowState: ContactFlowState? = nil,
        description: String? = nil,
        instanceId: String,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateContactFlowMetadataResponse {
        let input = UpdateContactFlowMetadataRequest(
            contactFlowId: contactFlowId, 
            contactFlowState: contactFlowState, 
            description: description, 
            instanceId: instanceId, 
            name: name
        )
        return try await self.updateContactFlowMetadata(input, logger: logger)
    }

    /// Updates specified flow module for the specified Amazon Connect instance.  Use the $SAVED alias in the request to describe the SAVED content of a Flow. For example, arn:aws:.../contact-flow/{id}:$SAVED. After a flow is published, $SAVED needs to be supplied to view saved content that has not been published.
    @Sendable
    @inlinable
    public func updateContactFlowModuleContent(_ input: UpdateContactFlowModuleContentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateContactFlowModuleContentResponse {
        try await self.client.execute(
            operation: "UpdateContactFlowModuleContent", 
            path: "/contact-flow-modules/{InstanceId}/{ContactFlowModuleId}/content", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates specified flow module for the specified Amazon Connect instance.  Use the $SAVED alias in the request to describe the SAVED content of a Flow. For example, arn:aws:.../contact-flow/{id}:$SAVED. After a flow is published, $SAVED needs to be supplied to view saved content that has not been published.
    ///
    /// Parameters:
    ///   - contactFlowModuleId: The identifier of the flow module.
    ///   - content: The JSON string that represents the content of the flow. For an example, see Example flow in Amazon Connect Flow language.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateContactFlowModuleContent(
        contactFlowModuleId: String,
        content: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateContactFlowModuleContentResponse {
        let input = UpdateContactFlowModuleContentRequest(
            contactFlowModuleId: contactFlowModuleId, 
            content: content, 
            instanceId: instanceId
        )
        return try await self.updateContactFlowModuleContent(input, logger: logger)
    }

    /// Updates metadata about specified flow module.
    @Sendable
    @inlinable
    public func updateContactFlowModuleMetadata(_ input: UpdateContactFlowModuleMetadataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateContactFlowModuleMetadataResponse {
        try await self.client.execute(
            operation: "UpdateContactFlowModuleMetadata", 
            path: "/contact-flow-modules/{InstanceId}/{ContactFlowModuleId}/metadata", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates metadata about specified flow module.
    ///
    /// Parameters:
    ///   - contactFlowModuleId: The identifier of the flow module.
    ///   - description: The description of the flow module.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the flow module.
    ///   - state: The state of flow module.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateContactFlowModuleMetadata(
        contactFlowModuleId: String,
        description: String? = nil,
        instanceId: String,
        name: String? = nil,
        state: ContactFlowModuleState? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateContactFlowModuleMetadataResponse {
        let input = UpdateContactFlowModuleMetadataRequest(
            contactFlowModuleId: contactFlowModuleId, 
            description: description, 
            instanceId: instanceId, 
            name: name, 
            state: state
        )
        return try await self.updateContactFlowModuleMetadata(input, logger: logger)
    }

    /// The name of the flow. You can also create and update flows using the Amazon Connect Flow language.
    @Sendable
    @inlinable
    public func updateContactFlowName(_ input: UpdateContactFlowNameRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateContactFlowNameResponse {
        try await self.client.execute(
            operation: "UpdateContactFlowName", 
            path: "/contact-flows/{InstanceId}/{ContactFlowId}/name", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// The name of the flow. You can also create and update flows using the Amazon Connect Flow language.
    ///
    /// Parameters:
    ///   - contactFlowId: The identifier of the flow.
    ///   - description: The description of the flow.
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - name: The name of the flow.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateContactFlowName(
        contactFlowId: String,
        description: String? = nil,
        instanceId: String,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateContactFlowNameResponse {
        let input = UpdateContactFlowNameRequest(
            contactFlowId: contactFlowId, 
            description: description, 
            instanceId: instanceId, 
            name: name
        )
        return try await self.updateContactFlowName(input, logger: logger)
    }

    /// Updates routing priority and age on the contact (QueuePriority and QueueTimeAdjustmentInSeconds). These properties can be used to change a customer's position in the queue. For example, you can move a contact to the back of the queue by setting a lower routing priority relative to other contacts in queue; or you can move a contact to the front of the queue by increasing the routing age which will make the contact look artificially older and therefore higher up in the first-in-first-out routing order. Note that adjusting the routing age of a contact affects only its position in queue, and not its actual queue wait time as reported through metrics. These properties can also be updated by using the Set routing priority / age flow block.  Either QueuePriority or QueueTimeAdjustmentInSeconds should be provided within the request body, but not both.
    @Sendable
    @inlinable
    public func updateContactRoutingData(_ input: UpdateContactRoutingDataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateContactRoutingDataResponse {
        try await self.client.execute(
            operation: "UpdateContactRoutingData", 
            path: "/contacts/{InstanceId}/{ContactId}/routing-data", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates routing priority and age on the contact (QueuePriority and QueueTimeAdjustmentInSeconds). These properties can be used to change a customer's position in the queue. For example, you can move a contact to the back of the queue by setting a lower routing priority relative to other contacts in queue; or you can move a contact to the front of the queue by increasing the routing age which will make the contact look artificially older and therefore higher up in the first-in-first-out routing order. Note that adjusting the routing age of a contact affects only its position in queue, and not its actual queue wait time as reported through metrics. These properties can also be updated by using the Set routing priority / age flow block.  Either QueuePriority or QueueTimeAdjustmentInSeconds should be provided within the request body, but not both.
    ///
    /// Parameters:
    ///   - contactId: The identifier of the contact in this instance of Amazon Connect.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - queuePriority: Priority of the contact in the queue. The default priority for new contacts is 5. You can raise the priority of a contact compared to other contacts in the queue by assigning them a higher priority, such as 1 or 2.
    ///   - queueTimeAdjustmentSeconds: The number of seconds to add or subtract from the contact's routing age. Contacts are routed to agents on a first-come, first-serve basis. This means that changing their amount of time in queue compared to others also changes their position in queue.
    ///   - routingCriteria: Updates the routing criteria on the contact. These properties can be used to change how a  contact is routed within the queue.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateContactRoutingData(
        contactId: String,
        instanceId: String,
        queuePriority: Int64? = nil,
        queueTimeAdjustmentSeconds: Int? = nil,
        routingCriteria: RoutingCriteriaInput? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateContactRoutingDataResponse {
        let input = UpdateContactRoutingDataRequest(
            contactId: contactId, 
            instanceId: instanceId, 
            queuePriority: queuePriority, 
            queueTimeAdjustmentSeconds: queueTimeAdjustmentSeconds, 
            routingCriteria: routingCriteria
        )
        return try await self.updateContactRoutingData(input, logger: logger)
    }

    /// Updates the scheduled time of a task contact that is already scheduled.
    @Sendable
    @inlinable
    public func updateContactSchedule(_ input: UpdateContactScheduleRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateContactScheduleResponse {
        try await self.client.execute(
            operation: "UpdateContactSchedule", 
            path: "/contact/schedule", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the scheduled time of a task contact that is already scheduled.
    ///
    /// Parameters:
    ///   - contactId: The identifier of the contact.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - scheduledTime: The timestamp, in Unix Epoch seconds format, at which to start running the inbound flow. The scheduled time cannot be in the past. It must be within up to 6 days in future.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateContactSchedule(
        contactId: String,
        instanceId: String,
        scheduledTime: Date,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateContactScheduleResponse {
        let input = UpdateContactScheduleRequest(
            contactId: contactId, 
            instanceId: instanceId, 
            scheduledTime: scheduledTime
        )
        return try await self.updateContactSchedule(input, logger: logger)
    }

    /// Updates an email address metadata. For more information about email addresses, see Create email addresses in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func updateEmailAddressMetadata(_ input: UpdateEmailAddressMetadataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateEmailAddressMetadataResponse {
        try await self.client.execute(
            operation: "UpdateEmailAddressMetadata", 
            path: "/email-addresses/{InstanceId}/{EmailAddressId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an email address metadata. For more information about email addresses, see Create email addresses in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - description: The description of the email address.
    ///   - displayName: The display name of email address.
    ///   - emailAddressId: The identifier of the email address.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateEmailAddressMetadata(
        clientToken: String? = nil,
        description: String? = nil,
        displayName: String? = nil,
        emailAddressId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateEmailAddressMetadataResponse {
        let input = UpdateEmailAddressMetadataRequest(
            clientToken: clientToken, 
            description: description, 
            displayName: displayName, 
            emailAddressId: emailAddressId, 
            instanceId: instanceId
        )
        return try await self.updateEmailAddressMetadata(input, logger: logger)
    }

    /// Updates details about a specific evaluation form version in the specified Amazon Connect instance. Question and section identifiers cannot be duplicated within the same evaluation form. This operation does not support partial updates. Instead it does a full update of evaluation form content.
    @Sendable
    @inlinable
    public func updateEvaluationForm(_ input: UpdateEvaluationFormRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateEvaluationFormResponse {
        try await self.client.execute(
            operation: "UpdateEvaluationForm", 
            path: "/evaluation-forms/{InstanceId}/{EvaluationFormId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates details about a specific evaluation form version in the specified Amazon Connect instance. Question and section identifiers cannot be duplicated within the same evaluation form. This operation does not support partial updates. Instead it does a full update of evaluation form content.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - createNewVersion: A flag indicating whether the operation must create a new version.
    ///   - description: The description of the evaluation form.
    ///   - evaluationFormId: The unique identifier for the evaluation form.
    ///   - evaluationFormVersion: A version of the evaluation form to update.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - items: Items that are part of the evaluation form.  The total number of sections and questions must not exceed 100 each.  Questions must be contained in a section.
    ///   - scoringStrategy: A scoring strategy of the evaluation form.
    ///   - title: A title of the evaluation form.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateEvaluationForm(
        clientToken: String? = UpdateEvaluationFormRequest.idempotencyToken(),
        createNewVersion: Bool? = nil,
        description: String? = nil,
        evaluationFormId: String,
        evaluationFormVersion: Int = 0,
        instanceId: String,
        items: [EvaluationFormItem],
        scoringStrategy: EvaluationFormScoringStrategy? = nil,
        title: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateEvaluationFormResponse {
        let input = UpdateEvaluationFormRequest(
            clientToken: clientToken, 
            createNewVersion: createNewVersion, 
            description: description, 
            evaluationFormId: evaluationFormId, 
            evaluationFormVersion: evaluationFormVersion, 
            instanceId: instanceId, 
            items: items, 
            scoringStrategy: scoringStrategy, 
            title: title
        )
        return try await self.updateEvaluationForm(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Updates the hours of operation.
    @Sendable
    @inlinable
    public func updateHoursOfOperation(_ input: UpdateHoursOfOperationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateHoursOfOperation", 
            path: "/hours-of-operations/{InstanceId}/{HoursOfOperationId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Updates the hours of operation.
    ///
    /// Parameters:
    ///   - config: Configuration information of the hours of operation.
    ///   - description: The description of the hours of operation.
    ///   - hoursOfOperationId: The identifier of the hours of operation.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the hours of operation.
    ///   - timeZone: The time zone of the hours of operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateHoursOfOperation(
        config: [HoursOfOperationConfig]? = nil,
        description: String? = nil,
        hoursOfOperationId: String,
        instanceId: String,
        name: String? = nil,
        timeZone: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateHoursOfOperationRequest(
            config: config, 
            description: description, 
            hoursOfOperationId: hoursOfOperationId, 
            instanceId: instanceId, 
            name: name, 
            timeZone: timeZone
        )
        return try await self.updateHoursOfOperation(input, logger: logger)
    }

    /// Update the hours of operation override.
    @Sendable
    @inlinable
    public func updateHoursOfOperationOverride(_ input: UpdateHoursOfOperationOverrideRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateHoursOfOperationOverride", 
            path: "/hours-of-operations/{InstanceId}/{HoursOfOperationId}/overrides/{HoursOfOperationOverrideId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update the hours of operation override.
    ///
    /// Parameters:
    ///   - config: Configuration information for the hours of operation override: day, start time, and end time.
    ///   - description: The description of the hours of operation override.
    ///   - effectiveFrom: The date from when the hours of operation override would be effective.
    ///   - effectiveTill: The date till when the hours of operation override would be effective.
    ///   - hoursOfOperationId: The identifier for the hours of operation.
    ///   - hoursOfOperationOverrideId: The identifier for the hours of operation override.
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - name: The name of the hours of operation override.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateHoursOfOperationOverride(
        config: [HoursOfOperationOverrideConfig]? = nil,
        description: String? = nil,
        effectiveFrom: String? = nil,
        effectiveTill: String? = nil,
        hoursOfOperationId: String,
        hoursOfOperationOverrideId: String,
        instanceId: String,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateHoursOfOperationOverrideRequest(
            config: config, 
            description: description, 
            effectiveFrom: effectiveFrom, 
            effectiveTill: effectiveTill, 
            hoursOfOperationId: hoursOfOperationId, 
            hoursOfOperationOverrideId: hoursOfOperationOverrideId, 
            instanceId: instanceId, 
            name: name
        )
        return try await self.updateHoursOfOperationOverride(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Updates the value for the specified attribute type.
    @Sendable
    @inlinable
    public func updateInstanceAttribute(_ input: UpdateInstanceAttributeRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateInstanceAttribute", 
            path: "/instance/{InstanceId}/attribute/{AttributeType}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Updates the value for the specified attribute type.
    ///
    /// Parameters:
    ///   - attributeType: The type of attribute.  Only allowlisted customers can consume USE_CUSTOM_TTS_VOICES. To access this feature, contact Amazon Web ServicesSupport for allowlisting.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - value: The value for the attribute. Maximum character limit is 100.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateInstanceAttribute(
        attributeType: InstanceAttributeType,
        clientToken: String? = UpdateInstanceAttributeRequest.idempotencyToken(),
        instanceId: String,
        value: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateInstanceAttributeRequest(
            attributeType: attributeType, 
            clientToken: clientToken, 
            instanceId: instanceId, 
            value: value
        )
        return try await self.updateInstanceAttribute(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Updates an existing configuration for a resource type. This API is idempotent.
    @Sendable
    @inlinable
    public func updateInstanceStorageConfig(_ input: UpdateInstanceStorageConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateInstanceStorageConfig", 
            path: "/instance/{InstanceId}/storage-config/{AssociationId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Updates an existing configuration for a resource type. This API is idempotent.
    ///
    /// Parameters:
    ///   - associationId: The existing association identifier that uniquely identifies the resource type and storage config for the given instance ID.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - resourceType: A valid resource type.
    ///   - storageConfig: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateInstanceStorageConfig(
        associationId: String,
        clientToken: String? = UpdateInstanceStorageConfigRequest.idempotencyToken(),
        instanceId: String,
        resourceType: InstanceStorageResourceType,
        storageConfig: InstanceStorageConfig,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateInstanceStorageConfigRequest(
            associationId: associationId, 
            clientToken: clientToken, 
            instanceId: instanceId, 
            resourceType: resourceType, 
            storageConfig: storageConfig
        )
        return try await self.updateInstanceStorageConfig(input, logger: logger)
    }

    /// Instructs Amazon Connect to resume the authentication process. The subsequent actions depend on the request body contents:    If a code is provided: Connect retrieves the identity information from Amazon Cognito and imports it into Connect Customer Profiles.    If an error is provided: The error branch of the Authenticate Customer block is executed.    The API returns a success response to acknowledge the request. However, the interaction and exchange of identity information occur asynchronously after the response is returned.
    @Sendable
    @inlinable
    public func updateParticipantAuthentication(_ input: UpdateParticipantAuthenticationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateParticipantAuthenticationResponse {
        try await self.client.execute(
            operation: "UpdateParticipantAuthentication", 
            path: "/contact/update-participant-authentication", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Instructs Amazon Connect to resume the authentication process. The subsequent actions depend on the request body contents:    If a code is provided: Connect retrieves the identity information from Amazon Cognito and imports it into Connect Customer Profiles.    If an error is provided: The error branch of the Authenticate Customer block is executed.    The API returns a success response to acknowledge the request. However, the interaction and exchange of identity information occur asynchronously after the response is returned.
    ///
    /// Parameters:
    ///   - code: The code query parameter provided by Cognito in the redirectUri.
    ///   - error: The error query parameter provided by Cognito in the redirectUri.
    ///   - errorDescription: The error_description parameter provided by Cognito in the redirectUri.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - state: The state query parameter that was provided by Cognito in the redirectUri. This will also match the state parameter provided in the AuthenticationUrl from the GetAuthenticationUrl response.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateParticipantAuthentication(
        code: String? = nil,
        error: String? = nil,
        errorDescription: String? = nil,
        instanceId: String,
        state: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateParticipantAuthenticationResponse {
        let input = UpdateParticipantAuthenticationRequest(
            code: code, 
            error: error, 
            errorDescription: errorDescription, 
            instanceId: instanceId, 
            state: state
        )
        return try await self.updateParticipantAuthentication(input, logger: logger)
    }

    /// Updates timeouts for when human chat participants are to be considered idle, and when agents are automatically disconnected from a chat due to idleness. You can set four timers:   Customer idle timeout   Customer auto-disconnect timeout   Agent idle timeout   Agent auto-disconnect timeout   For more information about how chat timeouts work, see  Set up chat timeouts for human participants.
    @Sendable
    @inlinable
    public func updateParticipantRoleConfig(_ input: UpdateParticipantRoleConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateParticipantRoleConfigResponse {
        try await self.client.execute(
            operation: "UpdateParticipantRoleConfig", 
            path: "/contact/participant-role-config/{InstanceId}/{ContactId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates timeouts for when human chat participants are to be considered idle, and when agents are automatically disconnected from a chat due to idleness. You can set four timers:   Customer idle timeout   Customer auto-disconnect timeout   Agent idle timeout   Agent auto-disconnect timeout   For more information about how chat timeouts work, see  Set up chat timeouts for human participants.
    ///
    /// Parameters:
    ///   - channelConfiguration: The Amazon Connect channel you want to configure.
    ///   - contactId: The identifier of the contact in this instance of Amazon Connect.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateParticipantRoleConfig(
        channelConfiguration: UpdateParticipantRoleConfigChannelInfo,
        contactId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateParticipantRoleConfigResponse {
        let input = UpdateParticipantRoleConfigRequest(
            channelConfiguration: channelConfiguration, 
            contactId: contactId, 
            instanceId: instanceId
        )
        return try await self.updateParticipantRoleConfig(input, logger: logger)
    }

    /// Updates your claimed phone number from its current Amazon Connect instance or traffic distribution group to another Amazon Connect instance or traffic distribution group in the same Amazon Web Services Region.  After using this API, you must verify that the phone number is attached to the correct flow in the target instance or traffic distribution group. You need to do this because the API switches only the phone number to a new instance or traffic distribution group. It doesn't migrate the flow configuration of the phone number, too. You can call DescribePhoneNumber API to verify the status of a previous UpdatePhoneNumber operation.
    @Sendable
    @inlinable
    public func updatePhoneNumber(_ input: UpdatePhoneNumberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdatePhoneNumberResponse {
        try await self.client.execute(
            operation: "UpdatePhoneNumber", 
            path: "/phone-number/{PhoneNumberId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates your claimed phone number from its current Amazon Connect instance or traffic distribution group to another Amazon Connect instance or traffic distribution group in the same Amazon Web Services Region.  After using this API, you must verify that the phone number is attached to the correct flow in the target instance or traffic distribution group. You need to do this because the API switches only the phone number to a new instance or traffic distribution group. It doesn't migrate the flow configuration of the phone number, too. You can call DescribePhoneNumber API to verify the status of a previous UpdatePhoneNumber operation.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - instanceId: The identifier of the Amazon Connect instance that phone numbers are claimed to. You can find the instance ID in the Amazon Resource Name (ARN) of the instance. You must enter InstanceId or TargetArn.
    ///   - phoneNumberId: A unique identifier for the phone number.
    ///   - targetArn: The Amazon Resource Name (ARN) for Amazon Connect instances or traffic distribution groups that phone number inbound traffic is routed through. You must enter InstanceId or TargetArn.
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePhoneNumber(
        clientToken: String? = UpdatePhoneNumberRequest.idempotencyToken(),
        instanceId: String? = nil,
        phoneNumberId: String,
        targetArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdatePhoneNumberResponse {
        let input = UpdatePhoneNumberRequest(
            clientToken: clientToken, 
            instanceId: instanceId, 
            phoneNumberId: phoneNumberId, 
            targetArn: targetArn
        )
        return try await self.updatePhoneNumber(input, logger: logger)
    }

    /// Updates a phone number’s metadata.  To verify the status of a previous UpdatePhoneNumberMetadata operation, call the DescribePhoneNumber API.
    @Sendable
    @inlinable
    public func updatePhoneNumberMetadata(_ input: UpdatePhoneNumberMetadataRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdatePhoneNumberMetadata", 
            path: "/phone-number/{PhoneNumberId}/metadata", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a phone number’s metadata.  To verify the status of a previous UpdatePhoneNumberMetadata operation, call the DescribePhoneNumber API.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If not provided, the Amazon Web Services SDK populates this field. For more information about idempotency, see Making retries safe with idempotent APIs.
    ///   - phoneNumberDescription: The description of the phone number.
    ///   - phoneNumberId: The Amazon Resource Name (ARN) or resource ID of the phone number.
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePhoneNumberMetadata(
        clientToken: String? = UpdatePhoneNumberMetadataRequest.idempotencyToken(),
        phoneNumberDescription: String? = nil,
        phoneNumberId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdatePhoneNumberMetadataRequest(
            clientToken: clientToken, 
            phoneNumberDescription: phoneNumberDescription, 
            phoneNumberId: phoneNumberId
        )
        return try await self.updatePhoneNumberMetadata(input, logger: logger)
    }

    /// Updates a predefined attribute for the specified Amazon Connect instance. Predefined attributes are attributes in an Amazon Connect instance that can be used to route contacts to an agent or pools of agents within a queue. For more information, see Create predefined attributes for routing contacts to agents.
    @Sendable
    @inlinable
    public func updatePredefinedAttribute(_ input: UpdatePredefinedAttributeRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdatePredefinedAttribute", 
            path: "/predefined-attributes/{InstanceId}/{Name}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a predefined attribute for the specified Amazon Connect instance. Predefined attributes are attributes in an Amazon Connect instance that can be used to route contacts to an agent or pools of agents within a queue. For more information, see Create predefined attributes for routing contacts to agents.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the predefined attribute.
    ///   - values: The values of the predefined attribute.
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePredefinedAttribute(
        instanceId: String,
        name: String,
        values: PredefinedAttributeValues? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdatePredefinedAttributeRequest(
            instanceId: instanceId, 
            name: name, 
            values: values
        )
        return try await self.updatePredefinedAttribute(input, logger: logger)
    }

    /// Updates a prompt.
    @Sendable
    @inlinable
    public func updatePrompt(_ input: UpdatePromptRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdatePromptResponse {
        try await self.client.execute(
            operation: "UpdatePrompt", 
            path: "/prompts/{InstanceId}/{PromptId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a prompt.
    ///
    /// Parameters:
    ///   - description: A description of the prompt.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the prompt.
    ///   - promptId: A unique identifier for the prompt.
    ///   - s3Uri: The URI for the S3 bucket where the prompt is stored. You can provide S3 pre-signed URLs returned by the
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePrompt(
        description: String? = nil,
        instanceId: String,
        name: String? = nil,
        promptId: String,
        s3Uri: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdatePromptResponse {
        let input = UpdatePromptRequest(
            description: description, 
            instanceId: instanceId, 
            name: name, 
            promptId: promptId, 
            s3Uri: s3Uri
        )
        return try await self.updatePrompt(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Updates the hours of operation for the specified queue.
    @Sendable
    @inlinable
    public func updateQueueHoursOfOperation(_ input: UpdateQueueHoursOfOperationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateQueueHoursOfOperation", 
            path: "/queues/{InstanceId}/{QueueId}/hours-of-operation", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Updates the hours of operation for the specified queue.
    ///
    /// Parameters:
    ///   - hoursOfOperationId: The identifier for the hours of operation.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - queueId: The identifier for the queue.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateQueueHoursOfOperation(
        hoursOfOperationId: String,
        instanceId: String,
        queueId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateQueueHoursOfOperationRequest(
            hoursOfOperationId: hoursOfOperationId, 
            instanceId: instanceId, 
            queueId: queueId
        )
        return try await self.updateQueueHoursOfOperation(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Updates the maximum number of contacts allowed in a queue before it is considered full.
    @Sendable
    @inlinable
    public func updateQueueMaxContacts(_ input: UpdateQueueMaxContactsRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateQueueMaxContacts", 
            path: "/queues/{InstanceId}/{QueueId}/max-contacts", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Updates the maximum number of contacts allowed in a queue before it is considered full.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxContacts: The maximum number of contacts that can be in the queue before it is considered full.
    ///   - queueId: The identifier for the queue.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateQueueMaxContacts(
        instanceId: String,
        maxContacts: Int? = nil,
        queueId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateQueueMaxContactsRequest(
            instanceId: instanceId, 
            maxContacts: maxContacts, 
            queueId: queueId
        )
        return try await self.updateQueueMaxContacts(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Updates the name and description of a queue. At least Name or Description must be provided.
    @Sendable
    @inlinable
    public func updateQueueName(_ input: UpdateQueueNameRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateQueueName", 
            path: "/queues/{InstanceId}/{QueueId}/name", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Updates the name and description of a queue. At least Name or Description must be provided.
    ///
    /// Parameters:
    ///   - description: The description of the queue.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the queue.
    ///   - queueId: The identifier for the queue.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateQueueName(
        description: String? = nil,
        instanceId: String,
        name: String? = nil,
        queueId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateQueueNameRequest(
            description: description, 
            instanceId: instanceId, 
            name: name, 
            queueId: queueId
        )
        return try await self.updateQueueName(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Updates the outbound caller ID name, number, and outbound whisper flow for a specified queue.    If the phone number is claimed to a traffic distribution group that was created in the same Region as the Amazon Connect instance where you are calling this API, then you can use a full phone number ARN or a UUID for OutboundCallerIdNumberId. However, if the phone number is claimed to a traffic distribution group that is in one Region, and you are calling this API from an instance in another Amazon Web Services Region that is associated with the traffic distribution group, you must provide a full phone number ARN. If a UUID is provided in this scenario, you will receive a ResourceNotFoundException.   Only use the phone number ARN format that doesn't contain instance in the path, for example, arn:aws:connect:us-east-1:1234567890:phone-number/uuid. This is the same ARN format that is returned when you call the ListPhoneNumbersV2 API.   If you plan to use IAM policies to allow/deny access to this API for phone number resources claimed to a traffic distribution group, see Allow or Deny queue API actions for phone numbers in a replica Region.
    @Sendable
    @inlinable
    public func updateQueueOutboundCallerConfig(_ input: UpdateQueueOutboundCallerConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateQueueOutboundCallerConfig", 
            path: "/queues/{InstanceId}/{QueueId}/outbound-caller-config", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Updates the outbound caller ID name, number, and outbound whisper flow for a specified queue.    If the phone number is claimed to a traffic distribution group that was created in the same Region as the Amazon Connect instance where you are calling this API, then you can use a full phone number ARN or a UUID for OutboundCallerIdNumberId. However, if the phone number is claimed to a traffic distribution group that is in one Region, and you are calling this API from an instance in another Amazon Web Services Region that is associated with the traffic distribution group, you must provide a full phone number ARN. If a UUID is provided in this scenario, you will receive a ResourceNotFoundException.   Only use the phone number ARN format that doesn't contain instance in the path, for example, arn:aws:connect:us-east-1:1234567890:phone-number/uuid. This is the same ARN format that is returned when you call the ListPhoneNumbersV2 API.   If you plan to use IAM policies to allow/deny access to this API for phone number resources claimed to a traffic distribution group, see Allow or Deny queue API actions for phone numbers in a replica Region.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - outboundCallerConfig: The outbound caller ID name, number, and outbound whisper flow.
    ///   - queueId: The identifier for the queue.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateQueueOutboundCallerConfig(
        instanceId: String,
        outboundCallerConfig: OutboundCallerConfig,
        queueId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateQueueOutboundCallerConfigRequest(
            instanceId: instanceId, 
            outboundCallerConfig: outboundCallerConfig, 
            queueId: queueId
        )
        return try await self.updateQueueOutboundCallerConfig(input, logger: logger)
    }

    /// Updates the outbound email address Id for a specified queue.
    @Sendable
    @inlinable
    public func updateQueueOutboundEmailConfig(_ input: UpdateQueueOutboundEmailConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateQueueOutboundEmailConfig", 
            path: "/queues/{InstanceId}/{QueueId}/outbound-email-config", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the outbound email address Id for a specified queue.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - outboundEmailConfig: The outbound email address ID for a specified queue.
    ///   - queueId: The identifier for the queue.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateQueueOutboundEmailConfig(
        instanceId: String,
        outboundEmailConfig: OutboundEmailConfig,
        queueId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateQueueOutboundEmailConfigRequest(
            instanceId: instanceId, 
            outboundEmailConfig: outboundEmailConfig, 
            queueId: queueId
        )
        return try await self.updateQueueOutboundEmailConfig(input, logger: logger)
    }

    /// This API is in preview release for Amazon Connect and is subject to change. Updates the status of the queue.
    @Sendable
    @inlinable
    public func updateQueueStatus(_ input: UpdateQueueStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateQueueStatus", 
            path: "/queues/{InstanceId}/{QueueId}/status", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// This API is in preview release for Amazon Connect and is subject to change. Updates the status of the queue.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - queueId: The identifier for the queue.
    ///   - status: The status of the queue.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateQueueStatus(
        instanceId: String,
        queueId: String,
        status: QueueStatus,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateQueueStatusRequest(
            instanceId: instanceId, 
            queueId: queueId, 
            status: status
        )
        return try await self.updateQueueStatus(input, logger: logger)
    }

    /// Updates the configuration settings for the specified quick connect.
    @Sendable
    @inlinable
    public func updateQuickConnectConfig(_ input: UpdateQuickConnectConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateQuickConnectConfig", 
            path: "/quick-connects/{InstanceId}/{QuickConnectId}/config", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the configuration settings for the specified quick connect.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - quickConnectConfig: Information about the configuration settings for the quick connect.
    ///   - quickConnectId: The identifier for the quick connect.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateQuickConnectConfig(
        instanceId: String,
        quickConnectConfig: QuickConnectConfig,
        quickConnectId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateQuickConnectConfigRequest(
            instanceId: instanceId, 
            quickConnectConfig: quickConnectConfig, 
            quickConnectId: quickConnectId
        )
        return try await self.updateQuickConnectConfig(input, logger: logger)
    }

    /// Updates the name and description of a quick connect. The request accepts the following data in JSON format. At least Name or Description must be provided.
    @Sendable
    @inlinable
    public func updateQuickConnectName(_ input: UpdateQuickConnectNameRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateQuickConnectName", 
            path: "/quick-connects/{InstanceId}/{QuickConnectId}/name", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the name and description of a quick connect. The request accepts the following data in JSON format. At least Name or Description must be provided.
    ///
    /// Parameters:
    ///   - description: The description of the quick connect.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the quick connect.
    ///   - quickConnectId: The identifier for the quick connect.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateQuickConnectName(
        description: String? = nil,
        instanceId: String,
        name: String? = nil,
        quickConnectId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateQuickConnectNameRequest(
            description: description, 
            instanceId: instanceId, 
            name: name, 
            quickConnectId: quickConnectId
        )
        return try await self.updateQuickConnectName(input, logger: logger)
    }

    /// Whether agents with this routing profile will have their routing order calculated based on time since their last inbound contact or longest idle time.
    @Sendable
    @inlinable
    public func updateRoutingProfileAgentAvailabilityTimer(_ input: UpdateRoutingProfileAgentAvailabilityTimerRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateRoutingProfileAgentAvailabilityTimer", 
            path: "/routing-profiles/{InstanceId}/{RoutingProfileId}/agent-availability-timer", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Whether agents with this routing profile will have their routing order calculated based on time since their last inbound contact or longest idle time.
    ///
    /// Parameters:
    ///   - agentAvailabilityTimer: Whether agents with this routing profile will have their routing order calculated based on time since their last inbound contact or longest idle time.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - routingProfileId: The identifier of the routing profile.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRoutingProfileAgentAvailabilityTimer(
        agentAvailabilityTimer: AgentAvailabilityTimer,
        instanceId: String,
        routingProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateRoutingProfileAgentAvailabilityTimerRequest(
            agentAvailabilityTimer: agentAvailabilityTimer, 
            instanceId: instanceId, 
            routingProfileId: routingProfileId
        )
        return try await self.updateRoutingProfileAgentAvailabilityTimer(input, logger: logger)
    }

    /// Updates the channels that agents can handle in the Contact Control Panel (CCP) for a routing profile.
    @Sendable
    @inlinable
    public func updateRoutingProfileConcurrency(_ input: UpdateRoutingProfileConcurrencyRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateRoutingProfileConcurrency", 
            path: "/routing-profiles/{InstanceId}/{RoutingProfileId}/concurrency", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the channels that agents can handle in the Contact Control Panel (CCP) for a routing profile.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - mediaConcurrencies: The channels that agents can handle in the Contact Control Panel (CCP).
    ///   - routingProfileId: The identifier of the routing profile.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRoutingProfileConcurrency(
        instanceId: String,
        mediaConcurrencies: [MediaConcurrency],
        routingProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateRoutingProfileConcurrencyRequest(
            instanceId: instanceId, 
            mediaConcurrencies: mediaConcurrencies, 
            routingProfileId: routingProfileId
        )
        return try await self.updateRoutingProfileConcurrency(input, logger: logger)
    }

    /// Updates the default outbound queue of a routing profile.
    @Sendable
    @inlinable
    public func updateRoutingProfileDefaultOutboundQueue(_ input: UpdateRoutingProfileDefaultOutboundQueueRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateRoutingProfileDefaultOutboundQueue", 
            path: "/routing-profiles/{InstanceId}/{RoutingProfileId}/default-outbound-queue", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the default outbound queue of a routing profile.
    ///
    /// Parameters:
    ///   - defaultOutboundQueueId: The identifier for the default outbound queue.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - routingProfileId: The identifier of the routing profile.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRoutingProfileDefaultOutboundQueue(
        defaultOutboundQueueId: String,
        instanceId: String,
        routingProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateRoutingProfileDefaultOutboundQueueRequest(
            defaultOutboundQueueId: defaultOutboundQueueId, 
            instanceId: instanceId, 
            routingProfileId: routingProfileId
        )
        return try await self.updateRoutingProfileDefaultOutboundQueue(input, logger: logger)
    }

    /// Updates the name and description of a routing profile. The request accepts the following data in JSON format. At least Name or Description must be provided.
    @Sendable
    @inlinable
    public func updateRoutingProfileName(_ input: UpdateRoutingProfileNameRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateRoutingProfileName", 
            path: "/routing-profiles/{InstanceId}/{RoutingProfileId}/name", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the name and description of a routing profile. The request accepts the following data in JSON format. At least Name or Description must be provided.
    ///
    /// Parameters:
    ///   - description: The description of the routing profile. Must not be more than 250 characters.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the routing profile. Must not be more than 127 characters.
    ///   - routingProfileId: The identifier of the routing profile.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRoutingProfileName(
        description: String? = nil,
        instanceId: String,
        name: String? = nil,
        routingProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateRoutingProfileNameRequest(
            description: description, 
            instanceId: instanceId, 
            name: name, 
            routingProfileId: routingProfileId
        )
        return try await self.updateRoutingProfileName(input, logger: logger)
    }

    /// Updates the properties associated with a set of queues for a routing profile.
    @Sendable
    @inlinable
    public func updateRoutingProfileQueues(_ input: UpdateRoutingProfileQueuesRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateRoutingProfileQueues", 
            path: "/routing-profiles/{InstanceId}/{RoutingProfileId}/queues", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the properties associated with a set of queues for a routing profile.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - queueConfigs: The queues to be updated for this routing profile. Queues must first be associated to the routing profile. You can do this using AssociateRoutingProfileQueues.
    ///   - routingProfileId: The identifier of the routing profile.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRoutingProfileQueues(
        instanceId: String,
        queueConfigs: [RoutingProfileQueueConfig],
        routingProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateRoutingProfileQueuesRequest(
            instanceId: instanceId, 
            queueConfigs: queueConfigs, 
            routingProfileId: routingProfileId
        )
        return try await self.updateRoutingProfileQueues(input, logger: logger)
    }

    /// Updates a rule for the specified Amazon Connect instance. Use the Rules Function language to code conditions for the rule.
    @Sendable
    @inlinable
    public func updateRule(_ input: UpdateRuleRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateRule", 
            path: "/rules/{InstanceId}/{RuleId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a rule for the specified Amazon Connect instance. Use the Rules Function language to code conditions for the rule.
    ///
    /// Parameters:
    ///   - actions: A list of actions to be run when the rule is triggered.
    ///   - function: The conditions of the rule.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the rule. You can change the name only if TriggerEventSource is one of the following values: OnZendeskTicketCreate | OnZendeskTicketStatusUpdate | OnSalesforceCaseCreate
    ///   - publishStatus: The publish status of the rule.
    ///   - ruleId: A unique identifier for the rule.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRule(
        actions: [RuleAction],
        function: String,
        instanceId: String,
        name: String,
        publishStatus: RulePublishStatus,
        ruleId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateRuleRequest(
            actions: actions, 
            function: function, 
            instanceId: instanceId, 
            name: name, 
            publishStatus: publishStatus, 
            ruleId: ruleId
        )
        return try await self.updateRule(input, logger: logger)
    }

    /// Updates a security profile. For information about security profiles, see Security Profiles in the Amazon Connect Administrator Guide. For a mapping of the API name and user interface name of the security profile permissions, see List of security profile permissions.
    @Sendable
    @inlinable
    public func updateSecurityProfile(_ input: UpdateSecurityProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateSecurityProfile", 
            path: "/security-profiles/{InstanceId}/{SecurityProfileId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a security profile. For information about security profiles, see Security Profiles in the Amazon Connect Administrator Guide. For a mapping of the API name and user interface name of the security profile permissions, see List of security profile permissions.
    ///
    /// Parameters:
    ///   - allowedAccessControlHierarchyGroupId: The identifier of the hierarchy group that a security profile uses to restrict access to resources in Amazon Connect.
    ///   - allowedAccessControlTags: The list of tags that a security profile uses to restrict access to resources in Amazon Connect.
    ///   - applications: A list of the third-party application's metadata.
    ///   - description: The description of the security profile.
    ///   - hierarchyRestrictedResources: The list of resources that a security profile applies hierarchy restrictions to in Amazon Connect. Following are acceptable ResourceNames: User.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - permissions: The permissions granted to a security profile. For a list of valid permissions, see List of security profile permissions.
    ///   - securityProfileId: The identifier for the security profle.
    ///   - tagRestrictedResources: The list of resources that a security profile applies tag restrictions to in Amazon Connect.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSecurityProfile(
        allowedAccessControlHierarchyGroupId: String? = nil,
        allowedAccessControlTags: [String: String]? = nil,
        applications: [Application]? = nil,
        description: String? = nil,
        hierarchyRestrictedResources: [String]? = nil,
        instanceId: String,
        permissions: [String]? = nil,
        securityProfileId: String,
        tagRestrictedResources: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateSecurityProfileRequest(
            allowedAccessControlHierarchyGroupId: allowedAccessControlHierarchyGroupId, 
            allowedAccessControlTags: allowedAccessControlTags, 
            applications: applications, 
            description: description, 
            hierarchyRestrictedResources: hierarchyRestrictedResources, 
            instanceId: instanceId, 
            permissions: permissions, 
            securityProfileId: securityProfileId, 
            tagRestrictedResources: tagRestrictedResources
        )
        return try await self.updateSecurityProfile(input, logger: logger)
    }

    /// Updates details about a specific task template in the specified Amazon Connect instance. This operation does not support partial updates. Instead it does a full update of template content.
    @Sendable
    @inlinable
    public func updateTaskTemplate(_ input: UpdateTaskTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateTaskTemplateResponse {
        try await self.client.execute(
            operation: "UpdateTaskTemplate", 
            path: "/instance/{InstanceId}/task/template/{TaskTemplateId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates details about a specific task template in the specified Amazon Connect instance. This operation does not support partial updates. Instead it does a full update of template content.
    ///
    /// Parameters:
    ///   - constraints: Constraints that are applicable to the fields listed.
    ///   - contactFlowId: The identifier of the flow that runs by default when a task is created by referencing this template.
    ///   - defaults: The default values for fields when a task is created by referencing this template.
    ///   - description: The description of the task template.
    ///   - fields: Fields that are part of the template.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the task template.
    ///   - selfAssignFlowId: The ContactFlowId for the flow that will be run if this template is used to create a self-assigned task.
    ///   - status: Marks a template as ACTIVE or INACTIVE for a task to refer to it.
    ///   - taskTemplateId: A unique identifier for the task template.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateTaskTemplate(
        constraints: TaskTemplateConstraints? = nil,
        contactFlowId: String? = nil,
        defaults: TaskTemplateDefaults? = nil,
        description: String? = nil,
        fields: [TaskTemplateField]? = nil,
        instanceId: String,
        name: String? = nil,
        selfAssignFlowId: String? = nil,
        status: TaskTemplateStatus? = nil,
        taskTemplateId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateTaskTemplateResponse {
        let input = UpdateTaskTemplateRequest(
            constraints: constraints, 
            contactFlowId: contactFlowId, 
            defaults: defaults, 
            description: description, 
            fields: fields, 
            instanceId: instanceId, 
            name: name, 
            selfAssignFlowId: selfAssignFlowId, 
            status: status, 
            taskTemplateId: taskTemplateId
        )
        return try await self.updateTaskTemplate(input, logger: logger)
    }

    /// Updates the traffic distribution for a given traffic distribution group.   When you shift telephony traffic, also shift agents and/or agent sign-ins to ensure they can handle the calls in the other Region. If you don't shift the agents, voice calls will go to the shifted Region but there won't be any agents available to receive the calls.   The SignInConfig distribution is available only on a
    /// default TrafficDistributionGroup (see the IsDefault parameter in the
    /// TrafficDistributionGroup data type). If you call UpdateTrafficDistribution with a modified SignInConfig and a non-default TrafficDistributionGroup, an InvalidRequestException is returned.  For more information about updating a traffic distribution group, see Update telephony traffic distribution across Amazon Web Services Regions in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func updateTrafficDistribution(_ input: UpdateTrafficDistributionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateTrafficDistributionResponse {
        try await self.client.execute(
            operation: "UpdateTrafficDistribution", 
            path: "/traffic-distribution/{Id}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the traffic distribution for a given traffic distribution group.   When you shift telephony traffic, also shift agents and/or agent sign-ins to ensure they can handle the calls in the other Region. If you don't shift the agents, voice calls will go to the shifted Region but there won't be any agents available to receive the calls.   The SignInConfig distribution is available only on a
    /// default TrafficDistributionGroup (see the IsDefault parameter in the
    /// TrafficDistributionGroup data type). If you call UpdateTrafficDistribution with a modified SignInConfig and a non-default TrafficDistributionGroup, an InvalidRequestException is returned.  For more information about updating a traffic distribution group, see Update telephony traffic distribution across Amazon Web Services Regions in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - agentConfig: The distribution of agents between the instance and its replica(s).
    ///   - id: The identifier of the traffic distribution group.
    ///   - signInConfig: The distribution that determines which Amazon Web Services Regions should be used to sign in agents in to both the instance and its replica(s).
    ///   - telephonyConfig: The distribution of traffic between the instance and its replica(s).
    ///   - logger: Logger use during operation
    @inlinable
    public func updateTrafficDistribution(
        agentConfig: AgentConfig? = nil,
        id: String,
        signInConfig: SignInConfig? = nil,
        telephonyConfig: TelephonyConfig? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateTrafficDistributionResponse {
        let input = UpdateTrafficDistributionRequest(
            agentConfig: agentConfig, 
            id: id, 
            signInConfig: signInConfig, 
            telephonyConfig: telephonyConfig
        )
        return try await self.updateTrafficDistribution(input, logger: logger)
    }

    /// Assigns the specified hierarchy group to the specified user.
    @Sendable
    @inlinable
    public func updateUserHierarchy(_ input: UpdateUserHierarchyRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateUserHierarchy", 
            path: "/users/{InstanceId}/{UserId}/hierarchy", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Assigns the specified hierarchy group to the specified user.
    ///
    /// Parameters:
    ///   - hierarchyGroupId: The identifier of the hierarchy group.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - userId: The identifier of the user account.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateUserHierarchy(
        hierarchyGroupId: String? = nil,
        instanceId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateUserHierarchyRequest(
            hierarchyGroupId: hierarchyGroupId, 
            instanceId: instanceId, 
            userId: userId
        )
        return try await self.updateUserHierarchy(input, logger: logger)
    }

    /// Updates the name of the user hierarchy group.
    @Sendable
    @inlinable
    public func updateUserHierarchyGroupName(_ input: UpdateUserHierarchyGroupNameRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateUserHierarchyGroupName", 
            path: "/user-hierarchy-groups/{InstanceId}/{HierarchyGroupId}/name", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the name of the user hierarchy group.
    ///
    /// Parameters:
    ///   - hierarchyGroupId: The identifier of the hierarchy group.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - name: The name of the hierarchy group. Must not be more than 100 characters.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateUserHierarchyGroupName(
        hierarchyGroupId: String,
        instanceId: String,
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateUserHierarchyGroupNameRequest(
            hierarchyGroupId: hierarchyGroupId, 
            instanceId: instanceId, 
            name: name
        )
        return try await self.updateUserHierarchyGroupName(input, logger: logger)
    }

    /// Updates the user hierarchy structure: add, remove, and rename user hierarchy levels.
    @Sendable
    @inlinable
    public func updateUserHierarchyStructure(_ input: UpdateUserHierarchyStructureRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateUserHierarchyStructure", 
            path: "/user-hierarchy-structure/{InstanceId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the user hierarchy structure: add, remove, and rename user hierarchy levels.
    ///
    /// Parameters:
    ///   - hierarchyStructure: The hierarchy levels to update.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateUserHierarchyStructure(
        hierarchyStructure: HierarchyStructureUpdate,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateUserHierarchyStructureRequest(
            hierarchyStructure: hierarchyStructure, 
            instanceId: instanceId
        )
        return try await self.updateUserHierarchyStructure(input, logger: logger)
    }

    /// Updates the identity information for the specified user.  We strongly recommend limiting who has the ability to invoke UpdateUserIdentityInfo. Someone with that ability can change the login credentials of other users by changing their email address. This poses a security risk to your organization. They can change the email address of a user to the attacker's email address, and then reset the password through email. For more information, see Best Practices for Security Profiles in the Amazon Connect Administrator Guide.
    @Sendable
    @inlinable
    public func updateUserIdentityInfo(_ input: UpdateUserIdentityInfoRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateUserIdentityInfo", 
            path: "/users/{InstanceId}/{UserId}/identity-info", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the identity information for the specified user.  We strongly recommend limiting who has the ability to invoke UpdateUserIdentityInfo. Someone with that ability can change the login credentials of other users by changing their email address. This poses a security risk to your organization. They can change the email address of a user to the attacker's email address, and then reset the password through email. For more information, see Best Practices for Security Profiles in the Amazon Connect Administrator Guide.
    ///
    /// Parameters:
    ///   - identityInfo: The identity information for the user.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - userId: The identifier of the user account.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateUserIdentityInfo(
        identityInfo: UserIdentityInfo,
        instanceId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateUserIdentityInfoRequest(
            identityInfo: identityInfo, 
            instanceId: instanceId, 
            userId: userId
        )
        return try await self.updateUserIdentityInfo(input, logger: logger)
    }

    /// Updates the phone configuration settings for the specified user.
    @Sendable
    @inlinable
    public func updateUserPhoneConfig(_ input: UpdateUserPhoneConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateUserPhoneConfig", 
            path: "/users/{InstanceId}/{UserId}/phone-config", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the phone configuration settings for the specified user.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - phoneConfig: Information about phone configuration settings for the user.
    ///   - userId: The identifier of the user account.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateUserPhoneConfig(
        instanceId: String,
        phoneConfig: UserPhoneConfig,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateUserPhoneConfigRequest(
            instanceId: instanceId, 
            phoneConfig: phoneConfig, 
            userId: userId
        )
        return try await self.updateUserPhoneConfig(input, logger: logger)
    }

    /// Updates the properties associated with the proficiencies of a user.
    @Sendable
    @inlinable
    public func updateUserProficiencies(_ input: UpdateUserProficienciesRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateUserProficiencies", 
            path: "/users/{InstanceId}/{UserId}/proficiencies", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the properties associated with the proficiencies of a user.
    ///
    /// Parameters:
    ///   - instanceId:  The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - userId: The identifier of the user account.
    ///   - userProficiencies: The proficiencies to be updated for the user. Proficiencies must first be associated to the user. You can do this using AssociateUserProficiencies API.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateUserProficiencies(
        instanceId: String,
        userId: String,
        userProficiencies: [UserProficiency],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateUserProficienciesRequest(
            instanceId: instanceId, 
            userId: userId, 
            userProficiencies: userProficiencies
        )
        return try await self.updateUserProficiencies(input, logger: logger)
    }

    /// Assigns the specified routing profile to the specified user.
    @Sendable
    @inlinable
    public func updateUserRoutingProfile(_ input: UpdateUserRoutingProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateUserRoutingProfile", 
            path: "/users/{InstanceId}/{UserId}/routing-profile", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Assigns the specified routing profile to the specified user.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - routingProfileId: The identifier of the routing profile for the user.
    ///   - userId: The identifier of the user account.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateUserRoutingProfile(
        instanceId: String,
        routingProfileId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateUserRoutingProfileRequest(
            instanceId: instanceId, 
            routingProfileId: routingProfileId, 
            userId: userId
        )
        return try await self.updateUserRoutingProfile(input, logger: logger)
    }

    /// Assigns the specified security profiles to the specified user.
    @Sendable
    @inlinable
    public func updateUserSecurityProfiles(_ input: UpdateUserSecurityProfilesRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateUserSecurityProfiles", 
            path: "/users/{InstanceId}/{UserId}/security-profiles", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Assigns the specified security profiles to the specified user.
    ///
    /// Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - securityProfileIds: The identifiers of the security profiles for the user.
    ///   - userId: The identifier of the user account.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateUserSecurityProfiles(
        instanceId: String,
        securityProfileIds: [String],
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateUserSecurityProfilesRequest(
            instanceId: instanceId, 
            securityProfileIds: securityProfileIds, 
            userId: userId
        )
        return try await self.updateUserSecurityProfiles(input, logger: logger)
    }

    /// Updates the view content of the given view identifier in the specified Amazon Connect instance. It performs content validation if Status is set to SAVED and performs full content validation if Status is PUBLISHED. Note that the $SAVED alias' content will always be updated, but the $LATEST alias' content will only be updated if Status is PUBLISHED.
    @Sendable
    @inlinable
    public func updateViewContent(_ input: UpdateViewContentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateViewContentResponse {
        try await self.client.execute(
            operation: "UpdateViewContent", 
            path: "/views/{InstanceId}/{ViewId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the view content of the given view identifier in the specified Amazon Connect instance. It performs content validation if Status is set to SAVED and performs full content validation if Status is PUBLISHED. Note that the $SAVED alias' content will always be updated, but the $LATEST alias' content will only be updated if Status is PUBLISHED.
    ///
    /// Parameters:
    ///   - content: View content containing all content necessary to render a view except for runtime input data and the runtime input schema, which is auto-generated by this operation. The total uncompressed content has a maximum file size of 400kB.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - status: Indicates the view status as either SAVED or PUBLISHED. The PUBLISHED status will initiate validation on the content.
    ///   - viewId: The identifier of the view. Both ViewArn and ViewId can be used.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateViewContent(
        content: ViewInputContent,
        instanceId: String,
        status: ViewStatus,
        viewId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateViewContentResponse {
        let input = UpdateViewContentRequest(
            content: content, 
            instanceId: instanceId, 
            status: status, 
            viewId: viewId
        )
        return try await self.updateViewContent(input, logger: logger)
    }

    /// Updates the view metadata. Note that either Name or Description must be provided.
    @Sendable
    @inlinable
    public func updateViewMetadata(_ input: UpdateViewMetadataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateViewMetadataResponse {
        try await self.client.execute(
            operation: "UpdateViewMetadata", 
            path: "/views/{InstanceId}/{ViewId}/metadata", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the view metadata. Note that either Name or Description must be provided.
    ///
    /// Parameters:
    ///   - description: The description of the view.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - name: The name of the view.
    ///   - viewId: The identifier of the view. Both ViewArn and ViewId can be used.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateViewMetadata(
        description: String? = nil,
        instanceId: String,
        name: String? = nil,
        viewId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateViewMetadataResponse {
        let input = UpdateViewMetadataRequest(
            description: description, 
            instanceId: instanceId, 
            name: name, 
            viewId: viewId
        )
        return try await self.updateViewMetadata(input, logger: logger)
    }
}

extension Connect {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: Connect, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Connect {
    /// Return PaginatorSequence for operation ``getCurrentMetricData(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getCurrentMetricDataPaginator(
        _ input: GetCurrentMetricDataRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetCurrentMetricDataRequest, GetCurrentMetricDataResponse> {
        return .init(
            input: input,
            command: self.getCurrentMetricData,
            inputKey: \GetCurrentMetricDataRequest.nextToken,
            outputKey: \GetCurrentMetricDataResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getCurrentMetricData(_:logger:)``.
    ///
    /// - Parameters:
    ///   - currentMetrics: The metrics to retrieve. Specify the name and unit for each metric. The following metrics are available. For a description of all the metrics, see Metrics definitions in the Amazon Connect Administrator Guide.  AGENTS_AFTER_CONTACT_WORK  Unit: COUNT Name in real-time metrics report: ACW   AGENTS_AVAILABLE  Unit: COUNT Name in real-time metrics report: Available   AGENTS_ERROR  Unit: COUNT Name in real-time metrics report: Error   AGENTS_NON_PRODUCTIVE  Unit: COUNT Name in real-time metrics report: NPT (Non-Productive Time)   AGENTS_ON_CALL  Unit: COUNT Name in real-time metrics report: On contact   AGENTS_ON_CONTACT  Unit: COUNT Name in real-time metrics report: On contact   AGENTS_ONLINE  Unit: COUNT Name in real-time metrics report: Online   AGENTS_STAFFED  Unit: COUNT Name in real-time metrics report: Staffed   CONTACTS_IN_QUEUE  Unit: COUNT Name in real-time metrics report: In queue   CONTACTS_SCHEDULED  Unit: COUNT Name in real-time metrics report: Scheduled   OLDEST_CONTACT_AGE  Unit: SECONDS When you use groupings, Unit says SECONDS and the Value is returned in SECONDS.  When you do not use groupings, Unit says SECONDS but the Value is returned in MILLISECONDS. For example, if you get a response like this:  { "Metric": { "Name": "OLDEST_CONTACT_AGE", "Unit": "SECONDS" }, "Value": 24113.0 } The actual OLDEST_CONTACT_AGE is 24 seconds. When the filter RoutingStepExpression is used, this metric is still calculated from enqueue time. For example, if a contact that has been queued under for 10 seconds has expired and  becomes active, then OLDEST_CONTACT_AGE for this queue will be counted starting from 10, not 0. Name in real-time metrics report: Oldest   SLOTS_ACTIVE  Unit: COUNT Name in real-time metrics report: Active   SLOTS_AVAILABLE  Unit: COUNT Name in real-time metrics report: Availability
    ///   - filters: The filters to apply to returned metrics. You can filter up to the following limits:   Queues: 100   Routing profiles: 100   Channels: 3 (VOICE, CHAT, and TASK channels are supported.)   RoutingStepExpressions: 50   Metric data is retrieved only for the resources associated with the queues or routing profiles, and by any channels included in the filter. (You cannot filter by both queue AND routing profile.) You can include both resource IDs and resource ARNs in the same request. When using the RoutingStepExpression filter, you need to pass exactly one QueueId. The filter is also case sensitive so when using the RoutingStepExpression filter, grouping by ROUTING_STEP_EXPRESSION is required. Currently tagging is only supported on the resources that are passed in the filter.
    ///   - groupings: The grouping applied to the metrics returned. For example, when grouped by QUEUE, the metrics returned apply to each queue rather than aggregated for all queues.    If you group by CHANNEL, you should include a Channels filter. VOICE, CHAT, and TASK channels are supported.   If you group by ROUTING_PROFILE, you must include either a queue or routing profile filter. In addition, a routing profile filter is required for metrics CONTACTS_SCHEDULED, CONTACTS_IN_QUEUE, and  OLDEST_CONTACT_AGE.   If no Grouping is included in the request, a summary of metrics is returned.   When using the RoutingStepExpression filter, group by ROUTING_STEP_EXPRESSION is required.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - sortCriteria: The way to sort the resulting response based on metrics. You can enter one sort criteria. By default resources are sorted based on AGENTS_ONLINE, DESCENDING. The metric collection is sorted based on the input metrics. Note the following:   Sorting on SLOTS_ACTIVE and SLOTS_AVAILABLE is not supported.
    ///   - logger: Logger used for logging
    @inlinable
    public func getCurrentMetricDataPaginator(
        currentMetrics: [CurrentMetric],
        filters: Filters,
        groupings: [Grouping]? = nil,
        instanceId: String,
        maxResults: Int? = nil,
        sortCriteria: [CurrentMetricSortCriteria]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetCurrentMetricDataRequest, GetCurrentMetricDataResponse> {
        let input = GetCurrentMetricDataRequest(
            currentMetrics: currentMetrics, 
            filters: filters, 
            groupings: groupings, 
            instanceId: instanceId, 
            maxResults: maxResults, 
            sortCriteria: sortCriteria
        )
        return self.getCurrentMetricDataPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getCurrentUserData(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getCurrentUserDataPaginator(
        _ input: GetCurrentUserDataRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetCurrentUserDataRequest, GetCurrentUserDataResponse> {
        return .init(
            input: input,
            command: self.getCurrentUserData,
            inputKey: \GetCurrentUserDataRequest.nextToken,
            outputKey: \GetCurrentUserDataResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getCurrentUserData(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: The filters to apply to returned user data. You can filter up to the following limits:   Queues: 100   Routing profiles: 100   Agents: 100   Contact states: 9   User hierarchy groups: 1   The user data is retrieved for only the specified values/resources in the filter. A maximum of one filter can be passed from queues, routing profiles, agents, and user hierarchy groups.  Currently tagging is only supported on the resources that are passed in the filter.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func getCurrentUserDataPaginator(
        filters: UserDataFilters,
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetCurrentUserDataRequest, GetCurrentUserDataResponse> {
        let input = GetCurrentUserDataRequest(
            filters: filters, 
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.getCurrentUserDataPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getMetricData(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getMetricDataPaginator(
        _ input: GetMetricDataRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetMetricDataRequest, GetMetricDataResponse> {
        return .init(
            input: input,
            command: self.getMetricData,
            inputKey: \GetMetricDataRequest.nextToken,
            outputKey: \GetMetricDataResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getMetricData(_:logger:)``.
    ///
    /// - Parameters:
    ///   - endTime: The timestamp, in UNIX Epoch time format, at which to end the reporting interval for the retrieval of historical metrics data. The time must be specified using an interval of 5 minutes, such as 11:00, 11:05, 11:10, and must be later than the start time timestamp. The time range between the start and end time must be less than 24 hours.
    ///   - filters: The queues, up to 100, or channels, to use to filter the metrics returned. Metric data is retrieved only for the resources associated with the queues or channels included in the filter. You can include both queue IDs and queue ARNs in the same request. VOICE, CHAT, and TASK channels are supported. RoutingStepExpression is not a valid filter for GetMetricData and we recommend switching to GetMetricDataV2 for more up-to-date features.  To filter by Queues, enter the queue ID/ARN, not the name of the queue.
    ///   - groupings: The grouping applied to the metrics returned. For example, when results are grouped by queue, the metrics returned are grouped by queue. The values returned apply to the metrics for each queue rather than aggregated for all queues. If no grouping is specified, a summary of metrics for all queues is returned. RoutingStepExpression is not a valid filter for GetMetricData and we recommend switching to GetMetricDataV2 for more up-to-date features.
    ///   - historicalMetrics: The metrics to retrieve. Specify the name, unit, and statistic for each metric. The following historical metrics are available. For a description of each metric, see Metrics definition in the Amazon Connect Administrator Guide.  This API does not support a contacts incoming metric (there's no CONTACTS_INCOMING metric missing from the documented list).    ABANDON_TIME  Unit: SECONDS Statistic: AVG  AFTER_CONTACT_WORK_TIME  Unit: SECONDS Statistic: AVG  API_CONTACTS_HANDLED  Unit: COUNT Statistic: SUM  CALLBACK_CONTACTS_HANDLED  Unit: COUNT Statistic: SUM  CONTACTS_ABANDONED  Unit: COUNT Statistic: SUM  CONTACTS_AGENT_HUNG_UP_FIRST  Unit: COUNT Statistic: SUM  CONTACTS_CONSULTED  Unit: COUNT Statistic: SUM  CONTACTS_HANDLED  Unit: COUNT Statistic: SUM  CONTACTS_HANDLED_INCOMING  Unit: COUNT Statistic: SUM  CONTACTS_HANDLED_OUTBOUND  Unit: COUNT Statistic: SUM  CONTACTS_HOLD_ABANDONS  Unit: COUNT Statistic: SUM  CONTACTS_MISSED  Unit: COUNT Statistic: SUM  CONTACTS_QUEUED  Unit: COUNT Statistic: SUM  CONTACTS_TRANSFERRED_IN  Unit: COUNT Statistic: SUM  CONTACTS_TRANSFERRED_IN_FROM_QUEUE  Unit: COUNT Statistic: SUM  CONTACTS_TRANSFERRED_OUT  Unit: COUNT Statistic: SUM  CONTACTS_TRANSFERRED_OUT_FROM_QUEUE  Unit: COUNT Statistic: SUM  HANDLE_TIME  Unit: SECONDS Statistic: AVG  HOLD_TIME  Unit: SECONDS Statistic: AVG  INTERACTION_AND_HOLD_TIME  Unit: SECONDS Statistic: AVG  INTERACTION_TIME  Unit: SECONDS Statistic: AVG  OCCUPANCY  Unit: PERCENT Statistic: AVG  QUEUE_ANSWER_TIME  Unit: SECONDS Statistic: AVG  QUEUED_TIME  Unit: SECONDS Statistic: MAX  SERVICE_LEVEL  You can include up to 20 SERVICE_LEVEL metrics in a request. Unit: PERCENT Statistic: AVG Threshold: For ThresholdValue, enter any whole number from 1 to 604800 (inclusive), in seconds. For Comparison, you must enter LT (for "Less than").
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - startTime: The timestamp, in UNIX Epoch time format, at which to start the reporting interval for the retrieval of historical metrics data. The time must be specified using a multiple of 5 minutes, such as 10:05, 10:10, 10:15. The start time cannot be earlier than 24 hours before the time of the request. Historical metrics are available only for 24 hours.
    ///   - logger: Logger used for logging
    @inlinable
    public func getMetricDataPaginator(
        endTime: Date,
        filters: Filters,
        groupings: [Grouping]? = nil,
        historicalMetrics: [HistoricalMetric],
        instanceId: String,
        maxResults: Int? = nil,
        startTime: Date,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetMetricDataRequest, GetMetricDataResponse> {
        let input = GetMetricDataRequest(
            endTime: endTime, 
            filters: filters, 
            groupings: groupings, 
            historicalMetrics: historicalMetrics, 
            instanceId: instanceId, 
            maxResults: maxResults, 
            startTime: startTime
        )
        return self.getMetricDataPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getMetricDataV2(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getMetricDataV2Paginator(
        _ input: GetMetricDataV2Request,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetMetricDataV2Request, GetMetricDataV2Response> {
        return .init(
            input: input,
            command: self.getMetricDataV2,
            inputKey: \GetMetricDataV2Request.nextToken,
            outputKey: \GetMetricDataV2Response.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getMetricDataV2(_:logger:)``.
    ///
    /// - Parameters:
    ///   - endTime: The timestamp, in UNIX Epoch time format, at which to end the reporting interval for the retrieval of historical metrics data. The time must be later than the start time timestamp. It cannot be later than the current timestamp.
    ///   - filters: The filters to apply to returned metrics. You can filter on the following resources:   Agents   Campaigns   Channels   Feature   Queues   Routing profiles   Routing step expression   User hierarchy groups   At least one filter must be passed from queues, routing profiles, agents, or user hierarchy groups. For metrics for outbound campaigns analytics, you can also use campaigns to satisfy at least one filter requirement. To filter by phone number, see Create a historical metrics report in the Amazon Connect Administrator Guide. Note the following limits:    Filter keys: A maximum of 5 filter keys are supported in a single request. Valid filter keys: AGENT | AGENT_HIERARCHY_LEVEL_ONE | AGENT_HIERARCHY_LEVEL_TWO | AGENT_HIERARCHY_LEVEL_THREE | AGENT_HIERARCHY_LEVEL_FOUR | AGENT_HIERARCHY_LEVEL_FIVE | ANSWERING_MACHINE_DETECTION_STATUS | BOT_ID | BOT_ALIAS | BOT_VERSION | BOT_LOCALE | BOT_INTENT_NAME | CAMPAIGN | CAMPAIGN_DELIVERY_EVENT_TYPE | CAMPAIGN_EXCLUDED_EVENT_TYPE  | CASE_TEMPLATE_ARN | CASE_STATUS | CHANNEL | contact/segmentAttributes/connect:Subtype | DISCONNECT_REASON | EVALUATION_FORM | EVALUATION_SECTION | EVALUATION_QUESTION | EVALUATION_SOURCE | FEATURE | FLOW_ACTION_ID | FLOW_TYPE | FLOWS_MODULE_RESOURCE_ID | FLOWS_NEXT_RESOURCE_ID | FLOWS_NEXT_RESOURCE_QUEUE_ID | FLOWS_OUTCOME_TYPE | FLOWS_RESOURCE_ID | FORM_VERSION | INITIATION_METHOD | INVOKING_RESOURCE_PUBLISHED_TIMESTAMP | INVOKING_RESOURCE_TYPE | PARENT_FLOWS_RESOURCE_ID | RESOURCE_PUBLISHED_TIMESTAMP | ROUTING_PROFILE | ROUTING_STEP_EXPRESSION | QUEUE | Q_CONNECT_ENABLED |     Filter values: A maximum of 100 filter values are supported in a single request. VOICE, CHAT, and TASK are valid filterValue for the CHANNEL filter key. They do not count towards limitation of 100 filter values. For example, a GetMetricDataV2 request can filter by 50 queues, 35 agents, and 15 routing profiles for a total of 100 filter values, along with 3 channel filters.   contact_lens_conversational_analytics is a valid filterValue for the FEATURE filter key. It is available only to contacts analyzed by Contact Lens conversational analytics.  connect:Chat, connect:SMS, connect:Telephony, and connect:WebRTC are valid filterValue examples (not exhaustive) for the contact/segmentAttributes/connect:Subtype filter key.  ROUTING_STEP_EXPRESSION is a valid filter key with a filter value up to 3000 length. This filter is case and order sensitive. JSON string fields must be sorted in ascending order and JSON array order should be kept as is.  Q_CONNECT_ENABLED. TRUE and FALSE are the only valid filterValues for the Q_CONNECT_ENABLED filter key.    TRUE includes all contacts that had Amazon Q in Connect enabled as part of the flow.   FALSE includes all contacts that did not have Amazon Q in Connect enabled as part of the flow   This filter is available only for contact record-driven metrics.   Campaign ARNs are valid filterValues for the CAMPAIGN filter key.
    ///   - groupings: The grouping applied to the metrics that are returned. For example, when results are grouped by queue, the metrics returned are grouped by queue. The values that are returned apply to the metrics for each queue. They are not aggregated for all queues. If no grouping is specified, a summary of all metrics is returned. Valid grouping keys: AGENT | AGENT_HIERARCHY_LEVEL_ONE | AGENT_HIERARCHY_LEVEL_TWO | AGENT_HIERARCHY_LEVEL_THREE | AGENT_HIERARCHY_LEVEL_FOUR | AGENT_HIERARCHY_LEVEL_FIVE | ANSWERING_MACHINE_DETECTION_STATUS | BOT_ID | BOT_ALIAS | BOT_VERSION | BOT_LOCALE | BOT_INTENT_NAME | CAMPAIGN | CAMPAIGN_DELIVERY_EVENT_TYPE | CAMPAIGN_EXCLUDED_EVENT_TYPE | CAMPAIGN_EXECUTION_TIMESTAMP | CASE_TEMPLATE_ARN | CASE_STATUS | CHANNEL | contact/segmentAttributes/connect:Subtype | DISCONNECT_REASON | EVALUATION_FORM | EVALUATION_SECTION | EVALUATION_QUESTION | EVALUATION_SOURCE | FLOWS_RESOURCE_ID | FLOWS_MODULE_RESOURCE_ID | FLOW_ACTION_ID | FLOW_TYPE | FLOWS_OUTCOME_TYPE | FORM_VERSION | INITIATION_METHOD | INVOKING_RESOURCE_PUBLISHED_TIMESTAMP | INVOKING_RESOURCE_TYPE | PARENT_FLOWS_RESOURCE_ID | Q_CONNECT_ENABLED | QUEUE | RESOURCE_PUBLISHED_TIMESTAMP | ROUTING_PROFILE | ROUTING_STEP_EXPRESSION  Type: Array of strings Array Members: Maximum number of 4 items Required: No
    ///   - interval: The interval period and timezone to apply to returned metrics.    IntervalPeriod: An aggregated grouping applied to request metrics. Valid IntervalPeriod values are: FIFTEEN_MIN | THIRTY_MIN | HOUR | DAY | WEEK | TOTAL.  For example, if IntervalPeriod is selected THIRTY_MIN, StartTime and EndTime differs by 1 day, then Amazon Connect returns 48 results in the response. Each result is aggregated by the THIRTY_MIN period. By default Amazon Connect aggregates results based on the TOTAL interval period.  The following list describes restrictions on StartTime and EndTime based on which IntervalPeriod is requested.     FIFTEEN_MIN: The difference between StartTime and EndTime must be less than 3 days.    THIRTY_MIN: The difference between StartTime and EndTime must be less than 3 days.    HOUR: The difference between StartTime and EndTime must be less than 3 days.    DAY: The difference between StartTime and EndTime must be less than 35 days.    WEEK: The difference between StartTime and EndTime must be less than 35 days.    TOTAL: The difference between StartTime and EndTime must be less than 35 days.      TimeZone: The timezone applied to requested metrics.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - metrics: The metrics to retrieve. Specify the name, groupings, and filters for each metric. The following historical metrics are available. For a description of each metric, see Metrics definition in the Amazon Connect Administrator Guide.  ABANDONMENT_RATE  Unit: Percent Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Abandonment rate   AGENT_ADHERENT_TIME  This metric is available only in Amazon Web Services Regions where Forecasting, capacity planning, and scheduling is available. Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy  UI name: Adherent time   AGENT_ANSWER_RATE  Unit: Percent Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy UI name: Agent answer rate   AGENT_NON_ADHERENT_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy UI name: Non-adherent time   AGENT_NON_RESPONSE  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy  UI name: Agent non-response   AGENT_NON_RESPONSE_WITHOUT_CUSTOMER_ABANDONS  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy Data for this metric is available starting from October 1, 2023 0:00:00 GMT. UI name: Agent non-response without customer abandons   AGENT_OCCUPANCY  Unit: Percentage Valid groupings and filters: Routing Profile, Agent, Agent Hierarchy  UI name: Occupancy   AGENT_SCHEDULE_ADHERENCE  This metric is available only in Amazon Web Services Regions where Forecasting, capacity planning, and scheduling is available. Unit: Percent Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy UI name: Adherence   AGENT_SCHEDULED_TIME  This metric is available only in Amazon Web Services Regions where Forecasting, capacity planning, and scheduling is available. Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy UI name: Scheduled time   AVG_ABANDON_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average queue abandon time   AVG_ACTIVE_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Average active time   AVG_AFTER_CONTACT_WORK_TIME  Unit: Seconds Valid metric filter key: INITIATION_METHOD  Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average after contact work time   Feature is a valid filter but not a valid grouping.   AVG_AGENT_CONNECTING_TIME  Unit: Seconds Valid metric filter key: INITIATION_METHOD. For now, this metric only supports the following as INITIATION_METHOD: INBOUND | OUTBOUND | CALLBACK | API  Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy UI name: Average agent API connecting time   The Negate key in metric-level filters is not applicable for this metric.   AVG_AGENT_PAUSE_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Average agent pause time   AVG_BOT_CONVERSATION_TIME  Unit: Seconds Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Bot ID, Bot alias, Bot version, Bot locale, Flows resource ID, Flows module resource ID, Flow type, Flow action ID, Invoking resource published timestamp, Initiation method, Invoking resource type, Parent flows resource ID UI name: Average bot conversation time   AVG_BOT_CONVERSATION_TURNS  Unit: Count Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Bot ID, Bot alias, Bot version, Bot locale, Flows resource ID, Flows module resource ID, Flow type, Flow action ID, Invoking resource published timestamp, Initiation method, Invoking resource type, Parent flows resource ID UI name: Average bot conversation turns   AVG_CASE_RELATED_CONTACTS  Unit: Count Required filter key: CASE_TEMPLATE_ARN Valid groupings and filters: CASE_TEMPLATE_ARN, CASE_STATUS UI name: Average contacts per case   AVG_CASE_RESOLUTION_TIME  Unit: Seconds Required filter key: CASE_TEMPLATE_ARN Valid groupings and filters: CASE_TEMPLATE_ARN, CASE_STATUS UI name: Average case resolution time   AVG_CONTACT_DURATION  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average contact duration   Feature is a valid filter but not a valid grouping.   AVG_CONVERSATION_DURATION  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average conversation duration   AVG_DIALS_PER_MINUTE  This metric is available only for outbound campaigns that use the agent assisted voice and automated voice delivery modes. Unit: Count Valid groupings and filters: Agent, Campaign, Queue, Routing Profile UI name: Average dials per minute   AVG_EVALUATION_SCORE  Unit: Percent Valid groupings and filters: Agent, Agent Hierarchy, Channel, Evaluation Form ID, Evaluation Section ID, Evaluation Question ID, Evaluation Source, Form Version, Queue, Routing Profile UI name: Average evaluation score   AVG_FLOW_TIME  Unit: Seconds Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Flow type, Flows module resource ID, Flows next resource ID, Flows next resource queue ID, Flows outcome type, Flows resource ID, Initiation method, Resource published timestamp UI name: Average flow time   AVG_GREETING_TIME_AGENT  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average agent greeting time   AVG_HANDLE_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, RoutingStepExpression UI name: Average handle time   Feature is a valid filter but not a valid grouping.   AVG_HOLD_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average customer hold time   Feature is a valid filter but not a valid grouping.   AVG_HOLD_TIME_ALL_CONTACTS  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average customer hold time all contacts   AVG_HOLDS  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average holds   Feature is a valid filter but not a valid grouping.   AVG_INTERACTION_AND_HOLD_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average agent interaction and customer hold time   AVG_INTERACTION_TIME  Unit: Seconds Valid metric filter key: INITIATION_METHOD  Valid groupings and filters: Queue, Channel, Routing Profile, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average agent interaction time   Feature is a valid filter but not a valid grouping.   AVG_INTERRUPTIONS_AGENT  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average agent interruptions   AVG_INTERRUPTION_TIME_AGENT  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average agent interruption time   AVG_NON_TALK_TIME  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average non-talk time   AVG_QUEUE_ANSWER_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average queue answer time   Feature is a valid filter but not a valid grouping.   AVG_RESOLUTION_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average resolution time   AVG_TALK_TIME  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average talk time   AVG_TALK_TIME_AGENT  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average agent talk time   AVG_TALK_TIME_CUSTOMER  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Average customer talk time   AVG_WAIT_TIME_AFTER_CUSTOMER_CONNECTION  This metric is available only for outbound campaigns that use the agent assisted voice and automated voice delivery modes. Unit: Seconds Valid groupings and filters: Campaign UI name: Average wait time after customer connection   AVG_WEIGHTED_EVALUATION_SCORE  Unit: Percent Valid groupings and filters: Agent, Agent Hierarchy, Channel, Evaluation Form Id, Evaluation Section ID, Evaluation Question ID, Evaluation Source, Form Version, Queue, Routing Profile UI name: Average weighted evaluation score   BOT_CONVERSATIONS_COMPLETED  Unit: Count Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Bot ID, Bot alias, Bot version, Bot locale, Flows resource ID, Flows module resource ID, Flow type, Flow action ID, Invoking resource published timestamp, Initiation method, Invoking resource type, Parent flows resource ID UI name: Bot conversations completed   BOT_INTENTS_COMPLETED  Unit: Count Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Bot ID, Bot alias, Bot version, Bot locale, Bot intent name, Flows resource ID, Flows module resource ID, Flow type, Flow action ID, Invoking resource published timestamp, Initiation method, Invoking resource type, Parent flows resource ID UI name: Bot intents completed   CAMPAIGN_CONTACTS_ABANDONED_AFTER_X  This metric is available only for outbound campaigns using the agent assisted voice and automated voice delivery modes. Unit: Count Valid groupings and filters: Agent, Campaign Threshold: For ThresholdValue, enter any whole number from 1 to 604800 (inclusive), in seconds. For Comparison, you must enter GT (for Greater than). UI name: Campaign contacts abandoned after X   CAMPAIGN_CONTACTS_ABANDONED_AFTER_X_RATE  This metric is available only for outbound campaigns using the agent assisted voice and automated voice delivery modes. Unit: Percent Valid groupings and filters: Agent, Campaign Threshold: For ThresholdValue, enter any whole number from 1 to 604800 (inclusive), in seconds. For Comparison, you must enter GT (for Greater than). UI name: Campaign contacts abandoned after X rate   CAMPAIGN_INTERACTIONS  This metric is available only for outbound campaigns using the email delivery mode.  Unit: Count Valid metric filter key: CAMPAIGN_INTERACTION_EVENT_TYPE Valid groupings and filters: Campaign UI name: Campaign interactions   CAMPAIGN_PROGRESS_RATE  This metric is only available for outbound campaigns initiated using a customer segment. It is not available for event triggered campaigns. Unit: Percent Valid groupings and filters: Campaign, Campaign Execution Timestamp UI name: Campaign progress rate   CAMPAIGN_SEND_ATTEMPTS  This metric is available only for outbound campaigns. Unit: Count Valid groupings and filters: Campaign, Channel, contact/segmentAttributes/connect:Subtype  UI name: Campaign send attempts   CAMPAIGN_SEND_EXCLUSIONS  This metric is available only for outbound campaigns. Valid metric filter key: CAMPAIGN_EXCLUDED_EVENT_TYPE Unit: Count Valid groupings and filters: Campaign, Campaign Excluded Event Type, Campaign Execution Timestamp UI name: Campaign send exclusions   CASES_CREATED  Unit: Count Required filter key: CASE_TEMPLATE_ARN Valid groupings and filters: CASE_TEMPLATE_ARN, CASE_STATUS UI name: Cases created   CONTACTS_CREATED  Unit: Count Valid metric filter key: INITIATION_METHOD  Valid groupings and filters: Queue, Channel, Routing Profile, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Contacts created   Feature is a valid filter but not a valid grouping.   CONTACTS_HANDLED  Unit: Count Valid metric filter key: INITIATION_METHOD, DISCONNECT_REASON  Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, RoutingStepExpression, Q in Connect UI name: API contacts handled   Feature is a valid filter but not a valid grouping.   CONTACTS_HANDLED_BY_CONNECTED_TO_AGENT  Unit: Count Valid metric filter key: INITIATION_METHOD  Valid groupings and filters: Queue, Channel, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Contacts handled (connected to agent timestamp)   CONTACTS_HOLD_ABANDONS  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Contacts hold disconnect   CONTACTS_ON_HOLD_AGENT_DISCONNECT  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Contacts hold agent disconnect   CONTACTS_ON_HOLD_CUSTOMER_DISCONNECT  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Contacts hold customer disconnect   CONTACTS_PUT_ON_HOLD  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Contacts put on hold   CONTACTS_TRANSFERRED_OUT_EXTERNAL  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Contacts transferred out external   CONTACTS_TRANSFERRED_OUT_INTERNAL  Unit: Percent Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Contacts transferred out internal   CONTACTS_QUEUED  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Contacts queued   CONTACTS_QUEUED_BY_ENQUEUE  Unit: Count Valid groupings and filters: Queue, Channel, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype UI name: Contacts queued (enqueue timestamp)   CONTACTS_REMOVED_FROM_QUEUE_IN_X  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Q in Connect Threshold: For ThresholdValue, enter any whole number from 1 to 604800 (inclusive), in seconds. For Comparison, you can use LT (for "Less than") or LTE (for "Less than equal"). UI name: Contacts removed from queue in X seconds   CONTACTS_RESOLVED_IN_X  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, contact/segmentAttributes/connect:Subtype, Q in Connect Threshold: For ThresholdValue, enter any whole number from 1 to 604800 (inclusive), in seconds. For Comparison, you can use LT (for "Less than") or LTE (for "Less than equal"). UI name: Contacts resolved in X   CONTACTS_TRANSFERRED_OUT  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Feature, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Contacts transferred out   Feature is a valid filter but not a valid grouping.   CONTACTS_TRANSFERRED_OUT_BY_AGENT  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Contacts transferred out by agent   CONTACTS_TRANSFERRED_OUT_FROM_QUEUE  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Contacts transferred out queue   CURRENT_CASES  Unit: Count Required filter key: CASE_TEMPLATE_ARN Valid groupings and filters: CASE_TEMPLATE_ARN, CASE_STATUS UI name: Current cases   DELIVERY_ATTEMPTS  This metric is available only for outbound campaigns. Unit: Count Valid metric filter key: ANSWERING_MACHINE_DETECTION_STATUS, CAMPAIGN_DELIVERY_EVENT_TYPE, DISCONNECT_REASON  Valid groupings and filters: Agent, Answering Machine Detection Status, Campaign, Campaign Delivery EventType, Channel, contact/segmentAttributes/connect:Subtype, Disconnect Reason, Queue, Routing Profile UI name: Delivery attempts   Campaign Delivery EventType filter and grouping are only available for SMS and Email campaign delivery modes. Agent, Queue, Routing Profile, Answering Machine Detection Status and Disconnect Reason are only available for agent assisted voice and automated voice delivery modes.    DELIVERY_ATTEMPT_DISPOSITION_RATE  This metric is available only for outbound campaigns. Dispositions for the agent assisted voice and automated voice delivery modes are only available with answering machine detection enabled. Unit: Percent Valid metric filter key: ANSWERING_MACHINE_DETECTION_STATUS, CAMPAIGN_DELIVERY_EVENT_TYPE, DISCONNECT_REASON  Valid groupings and filters: Agent, Answering Machine Detection Status, Campaign, Channel, contact/segmentAttributes/connect:Subtype, Disconnect Reason, Queue, Routing Profile UI name: Delivery attempt disposition rate   Campaign Delivery Event Type filter and grouping are only available for SMS and Email campaign delivery modes. Agent, Queue, Routing Profile, Answering Machine Detection Status and Disconnect Reason are only available for agent assisted voice and automated voice delivery modes.    EVALUATIONS_PERFORMED  Unit: Count Valid groupings and filters: Agent, Agent Hierarchy, Channel, Evaluation Form ID, Evaluation Source, Form Version, Queue, Routing Profile UI name: Evaluations performed   FLOWS_OUTCOME  Unit: Count Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Flow type, Flows module resource ID, Flows next resource ID, Flows next resource queue ID, Flows outcome type, Flows resource ID, Initiation method, Resource published timestamp UI name: Flows outcome   FLOWS_STARTED  Unit: Count Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Flow type, Flows module resource ID, Flows resource ID, Initiation method, Resource published timestamp UI name: Flows started   HUMAN_ANSWERED_CALLS  This metric is available only for outbound campaigns. Dispositions for the agent assisted voice and automated voice delivery modes are only available with answering machine detection enabled.  Unit: Count Valid groupings and filters: Agent, Campaign UI name: Human answered   MAX_FLOW_TIME  Unit: Seconds Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Flow type, Flows module resource ID, Flows next resource ID, Flows next resource queue ID, Flows outcome type, Flows resource ID, Initiation method, Resource published timestamp UI name: Maximum flow time   MAX_QUEUED_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Maximum queued time   MIN_FLOW_TIME  Unit: Seconds Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Flow type, Flows module resource ID, Flows next resource ID, Flows next resource queue ID, Flows outcome type, Flows resource ID, Initiation method, Resource published timestamp UI name: Minimum flow time   PERCENT_AUTOMATIC_FAILS  Unit: Percent Valid groupings and filters: Agent, Agent Hierarchy, Channel, Evaluation Form ID, Evaluation Source, Form Version, Queue, Routing Profile UI name: Automatic fails percent   PERCENT_BOT_CONVERSATIONS_OUTCOME  Unit: Percent Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Bot ID, Bot alias, Bot version, Bot locale, Flows resource ID, Flows module resource ID, Flow type, Flow action ID, Invoking resource published timestamp, Initiation method, Invoking resource type, Parent flows resource ID UI name: Percent bot conversations outcome   PERCENT_BOT_INTENTS_OUTCOME  Unit: Percent Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Bot ID, Bot alias, Bot version, Bot locale, Bot intent name, Flows resource ID, Flows module resource ID, Flow type, Flow action ID, Invoking resource published timestamp, Initiation method, Invoking resource type, Parent flows resource ID UI name: Percent bot intents outcome   PERCENT_CASES_FIRST_CONTACT_RESOLVED  Unit: Percent Required filter key: CASE_TEMPLATE_ARN Valid groupings and filters: CASE_TEMPLATE_ARN, CASE_STATUS UI name: Cases resolved on first contact   PERCENT_CONTACTS_STEP_EXPIRED  Unit: Percent Valid groupings and filters: Queue, RoutingStepExpression UI name: This metric is available in Real-time Metrics UI but not on the Historical Metrics UI.  PERCENT_CONTACTS_STEP_JOINED  Unit: Percent Valid groupings and filters: Queue, RoutingStepExpression UI name: This metric is available in Real-time Metrics UI but not on the Historical Metrics UI.  PERCENT_FLOWS_OUTCOME  Unit: Percent Valid metric filter key: FLOWS_OUTCOME_TYPE  Valid groupings and filters: Channel, contact/segmentAttributes/connect:Subtype, Flow type, Flows module resource ID, Flows next resource ID, Flows next resource queue ID, Flows outcome type, Flows resource ID, Initiation method, Resource published timestamp UI name: Flows outcome percentage.  The FLOWS_OUTCOME_TYPE is not a valid grouping.   PERCENT_NON_TALK_TIME  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Percentage Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Non-talk time percent   PERCENT_TALK_TIME  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Percentage Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Talk time percent   PERCENT_TALK_TIME_AGENT  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Percentage Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Agent talk time percent   PERCENT_TALK_TIME_CUSTOMER  This metric is available only for contacts analyzed by Contact Lens conversational analytics. Unit: Percentage Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Customer talk time percent   RECIPIENTS_ATTEMPTED  This metric is only available for outbound campaigns initiated using a customer segment. It is not available for event triggered campaigns. Unit: Count Valid groupings and filters: Campaign, Campaign Execution Timestamp UI name: Recipients attempted   RECIPIENTS_INTERACTED  This metric is only available for outbound campaigns initiated using a customer segment. It is not available for event triggered campaigns. Valid metric filter key: CAMPAIGN_INTERACTION_EVENT_TYPE Unit: Count Valid groupings and filters: Campaign, Channel, contact/segmentAttributes/connect:Subtype, Campaign Execution Timestamp UI name: Recipients interacted   RECIPIENTS_TARGETED  This metric is only available for outbound campaigns initiated using a customer segment. It is not available for event triggered campaigns. Unit: Count Valid groupings and filters: Campaign, Campaign Execution Timestamp UI name: Recipients targeted   REOPENED_CASE_ACTIONS  Unit: Count Required filter key: CASE_TEMPLATE_ARN Valid groupings and filters: CASE_TEMPLATE_ARN, CASE_STATUS UI name: Cases reopened   RESOLVED_CASE_ACTIONS  Unit: Count Required filter key: CASE_TEMPLATE_ARN Valid groupings and filters: CASE_TEMPLATE_ARN, CASE_STATUS UI name: Cases resolved   SERVICE_LEVEL  You can include up to 20 SERVICE_LEVEL metrics in a request. Unit: Percent Valid groupings and filters: Queue, Channel, Routing Profile, Q in Connect Threshold: For ThresholdValue, enter any whole number from 1 to 604800 (inclusive), in seconds. For Comparison, you can use LT (for "Less than") or LTE (for "Less than equal"). UI name: Service level X   STEP_CONTACTS_QUEUED  Unit: Count Valid groupings and filters: Queue, RoutingStepExpression UI name: This metric is available in Real-time Metrics UI but not on the Historical Metrics UI.  SUM_AFTER_CONTACT_WORK_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: After contact work time   SUM_CONNECTING_TIME_AGENT  Unit: Seconds Valid metric filter key: INITIATION_METHOD. This metric only supports the following filter keys as INITIATION_METHOD: INBOUND | OUTBOUND | CALLBACK | API  Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy UI name: Agent API connecting time   The Negate key in metric-level filters is not applicable for this metric.   CONTACTS_ABANDONED  Unit: Count Metric filter:    Valid values: API| Incoming | Outbound | Transfer | Callback | Queue_Transfer| Disconnect    Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, RoutingStepExpression, Q in Connect UI name: Contact abandoned   SUM_CONTACTS_ABANDONED_IN_X  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, contact/segmentAttributes/connect:Subtype, Q in Connect Threshold: For ThresholdValue, enter any whole number from 1 to 604800 (inclusive), in seconds. For Comparison, you can use LT (for "Less than") or LTE (for "Less than equal"). UI name: Contacts abandoned in X seconds   SUM_CONTACTS_ANSWERED_IN_X  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, contact/segmentAttributes/connect:Subtype, Q in Connect Threshold: For ThresholdValue, enter any whole number from 1 to 604800 (inclusive), in seconds. For Comparison, you can use LT (for "Less than") or LTE (for "Less than equal"). UI name: Contacts answered in X seconds   SUM_CONTACT_FLOW_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Contact flow time   SUM_CONTACT_TIME_AGENT  Unit: Seconds Valid groupings and filters: Routing Profile, Agent, Agent Hierarchy UI name: Agent on contact time   SUM_CONTACTS_DISCONNECTED   Valid metric filter key: DISCONNECT_REASON  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Contact disconnected   SUM_ERROR_STATUS_TIME_AGENT  Unit: Seconds Valid groupings and filters: Routing Profile, Agent, Agent Hierarchy UI name: Error status time   SUM_HANDLE_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Contact handle time   SUM_HOLD_TIME  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Customer hold time   SUM_IDLE_TIME_AGENT  Unit: Seconds Valid groupings and filters: Routing Profile, Agent, Agent Hierarchy UI name: Agent idle time   SUM_INTERACTION_AND_HOLD_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy, Q in Connect UI name: Agent interaction and hold time   SUM_INTERACTION_TIME  Unit: Seconds Valid groupings and filters: Queue, Channel, Routing Profile, Agent, Agent Hierarchy UI name: Agent interaction time   SUM_NON_PRODUCTIVE_TIME_AGENT  Unit: Seconds Valid groupings and filters: Routing Profile, Agent, Agent Hierarchy UI name: Agent non-productive time   SUM_ONLINE_TIME_AGENT  Unit: Seconds Valid groupings and filters: Routing Profile, Agent, Agent Hierarchy UI name: Online time   SUM_RETRY_CALLBACK_ATTEMPTS  Unit: Count Valid groupings and filters: Queue, Channel, Routing Profile, contact/segmentAttributes/connect:Subtype, Q in Connect UI name: Callback attempts
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource. This includes the instanceId an Amazon Connect instance.
    ///   - startTime: The timestamp, in UNIX Epoch time format, at which to start the reporting interval for the retrieval of historical metrics data. The time must be before the end time timestamp. The start and end time depends on the IntervalPeriod selected. By default the time range between start and end time is 35 days. Historical metrics are available for 3 months.
    ///   - logger: Logger used for logging
    @inlinable
    public func getMetricDataV2Paginator(
        endTime: Date,
        filters: [FilterV2],
        groupings: [String]? = nil,
        interval: IntervalDetails? = nil,
        maxResults: Int? = nil,
        metrics: [MetricV2],
        resourceArn: String,
        startTime: Date,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetMetricDataV2Request, GetMetricDataV2Response> {
        let input = GetMetricDataV2Request(
            endTime: endTime, 
            filters: filters, 
            groupings: groupings, 
            interval: interval, 
            maxResults: maxResults, 
            metrics: metrics, 
            resourceArn: resourceArn, 
            startTime: startTime
        )
        return self.getMetricDataV2Paginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAgentStatuses(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAgentStatusesPaginator(
        _ input: ListAgentStatusRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAgentStatusRequest, ListAgentStatusResponse> {
        return .init(
            input: input,
            command: self.listAgentStatuses,
            inputKey: \ListAgentStatusRequest.nextToken,
            outputKey: \ListAgentStatusResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAgentStatuses(_:logger:)``.
    ///
    /// - Parameters:
    ///   - agentStatusTypes: Available agent status types.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAgentStatusesPaginator(
        agentStatusTypes: [AgentStatusType]? = nil,
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAgentStatusRequest, ListAgentStatusResponse> {
        let input = ListAgentStatusRequest(
            agentStatusTypes: agentStatusTypes, 
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listAgentStatusesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listApprovedOrigins(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listApprovedOriginsPaginator(
        _ input: ListApprovedOriginsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListApprovedOriginsRequest, ListApprovedOriginsResponse> {
        return .init(
            input: input,
            command: self.listApprovedOrigins,
            inputKey: \ListApprovedOriginsRequest.nextToken,
            outputKey: \ListApprovedOriginsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listApprovedOrigins(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listApprovedOriginsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListApprovedOriginsRequest, ListApprovedOriginsResponse> {
        let input = ListApprovedOriginsRequest(
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listApprovedOriginsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAuthenticationProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAuthenticationProfilesPaginator(
        _ input: ListAuthenticationProfilesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAuthenticationProfilesRequest, ListAuthenticationProfilesResponse> {
        return .init(
            input: input,
            command: self.listAuthenticationProfiles,
            inputKey: \ListAuthenticationProfilesRequest.nextToken,
            outputKey: \ListAuthenticationProfilesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAuthenticationProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAuthenticationProfilesPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAuthenticationProfilesRequest, ListAuthenticationProfilesResponse> {
        let input = ListAuthenticationProfilesRequest(
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listAuthenticationProfilesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listBots(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listBotsPaginator(
        _ input: ListBotsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListBotsRequest, ListBotsResponse> {
        return .init(
            input: input,
            command: self.listBots,
            inputKey: \ListBotsRequest.nextToken,
            outputKey: \ListBotsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listBots(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - lexVersion: The version of Amazon Lex or Amazon Lex V2.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listBotsPaginator(
        instanceId: String,
        lexVersion: LexVersion,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListBotsRequest, ListBotsResponse> {
        let input = ListBotsRequest(
            instanceId: instanceId, 
            lexVersion: lexVersion, 
            maxResults: maxResults
        )
        return self.listBotsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listContactEvaluations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listContactEvaluationsPaginator(
        _ input: ListContactEvaluationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListContactEvaluationsRequest, ListContactEvaluationsResponse> {
        return .init(
            input: input,
            command: self.listContactEvaluations,
            inputKey: \ListContactEvaluationsRequest.nextToken,
            outputKey: \ListContactEvaluationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listContactEvaluations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - contactId: The identifier of the contact in this instance of Amazon Connect.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - logger: Logger used for logging
    @inlinable
    public func listContactEvaluationsPaginator(
        contactId: String,
        instanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListContactEvaluationsRequest, ListContactEvaluationsResponse> {
        let input = ListContactEvaluationsRequest(
            contactId: contactId, 
            instanceId: instanceId
        )
        return self.listContactEvaluationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listContactFlowModules(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listContactFlowModulesPaginator(
        _ input: ListContactFlowModulesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListContactFlowModulesRequest, ListContactFlowModulesResponse> {
        return .init(
            input: input,
            command: self.listContactFlowModules,
            inputKey: \ListContactFlowModulesRequest.nextToken,
            outputKey: \ListContactFlowModulesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listContactFlowModules(_:logger:)``.
    ///
    /// - Parameters:
    ///   - contactFlowModuleState: The state of the flow module.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listContactFlowModulesPaginator(
        contactFlowModuleState: ContactFlowModuleState? = nil,
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListContactFlowModulesRequest, ListContactFlowModulesResponse> {
        let input = ListContactFlowModulesRequest(
            contactFlowModuleState: contactFlowModuleState, 
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listContactFlowModulesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listContactFlowVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listContactFlowVersionsPaginator(
        _ input: ListContactFlowVersionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListContactFlowVersionsRequest, ListContactFlowVersionsResponse> {
        return .init(
            input: input,
            command: self.listContactFlowVersions,
            inputKey: \ListContactFlowVersionsRequest.nextToken,
            outputKey: \ListContactFlowVersionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listContactFlowVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - contactFlowId: The identifier of the flow.
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func listContactFlowVersionsPaginator(
        contactFlowId: String,
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListContactFlowVersionsRequest, ListContactFlowVersionsResponse> {
        let input = ListContactFlowVersionsRequest(
            contactFlowId: contactFlowId, 
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listContactFlowVersionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listContactFlows(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listContactFlowsPaginator(
        _ input: ListContactFlowsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListContactFlowsRequest, ListContactFlowsResponse> {
        return .init(
            input: input,
            command: self.listContactFlows,
            inputKey: \ListContactFlowsRequest.nextToken,
            outputKey: \ListContactFlowsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listContactFlows(_:logger:)``.
    ///
    /// - Parameters:
    ///   - contactFlowTypes: The type of flow.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func listContactFlowsPaginator(
        contactFlowTypes: [ContactFlowType]? = nil,
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListContactFlowsRequest, ListContactFlowsResponse> {
        let input = ListContactFlowsRequest(
            contactFlowTypes: contactFlowTypes, 
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listContactFlowsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listContactReferences(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listContactReferencesPaginator(
        _ input: ListContactReferencesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListContactReferencesRequest, ListContactReferencesResponse> {
        return .init(
            input: input,
            command: self.listContactReferences,
            inputKey: \ListContactReferencesRequest.nextToken,
            outputKey: \ListContactReferencesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listContactReferences(_:logger:)``.
    ///
    /// - Parameters:
    ///   - contactId: The identifier of the initial contact.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - referenceTypes: The type of reference.
    ///   - logger: Logger used for logging
    @inlinable
    public func listContactReferencesPaginator(
        contactId: String,
        instanceId: String,
        referenceTypes: [ReferenceType],
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListContactReferencesRequest, ListContactReferencesResponse> {
        let input = ListContactReferencesRequest(
            contactId: contactId, 
            instanceId: instanceId, 
            referenceTypes: referenceTypes
        )
        return self.listContactReferencesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDefaultVocabularies(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDefaultVocabulariesPaginator(
        _ input: ListDefaultVocabulariesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDefaultVocabulariesRequest, ListDefaultVocabulariesResponse> {
        return .init(
            input: input,
            command: self.listDefaultVocabularies,
            inputKey: \ListDefaultVocabulariesRequest.nextToken,
            outputKey: \ListDefaultVocabulariesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDefaultVocabularies(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - languageCode: The language code of the vocabulary entries. For a list of languages and their corresponding language codes, see
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDefaultVocabulariesPaginator(
        instanceId: String,
        languageCode: VocabularyLanguageCode? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDefaultVocabulariesRequest, ListDefaultVocabulariesResponse> {
        let input = ListDefaultVocabulariesRequest(
            instanceId: instanceId, 
            languageCode: languageCode, 
            maxResults: maxResults
        )
        return self.listDefaultVocabulariesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listEvaluationFormVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listEvaluationFormVersionsPaginator(
        _ input: ListEvaluationFormVersionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListEvaluationFormVersionsRequest, ListEvaluationFormVersionsResponse> {
        return .init(
            input: input,
            command: self.listEvaluationFormVersions,
            inputKey: \ListEvaluationFormVersionsRequest.nextToken,
            outputKey: \ListEvaluationFormVersionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listEvaluationFormVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - evaluationFormId: The unique identifier for the evaluation form.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listEvaluationFormVersionsPaginator(
        evaluationFormId: String,
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListEvaluationFormVersionsRequest, ListEvaluationFormVersionsResponse> {
        let input = ListEvaluationFormVersionsRequest(
            evaluationFormId: evaluationFormId, 
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listEvaluationFormVersionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listEvaluationForms(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listEvaluationFormsPaginator(
        _ input: ListEvaluationFormsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListEvaluationFormsRequest, ListEvaluationFormsResponse> {
        return .init(
            input: input,
            command: self.listEvaluationForms,
            inputKey: \ListEvaluationFormsRequest.nextToken,
            outputKey: \ListEvaluationFormsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listEvaluationForms(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listEvaluationFormsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListEvaluationFormsRequest, ListEvaluationFormsResponse> {
        let input = ListEvaluationFormsRequest(
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listEvaluationFormsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listFlowAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listFlowAssociationsPaginator(
        _ input: ListFlowAssociationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListFlowAssociationsRequest, ListFlowAssociationsResponse> {
        return .init(
            input: input,
            command: self.listFlowAssociations,
            inputKey: \ListFlowAssociationsRequest.nextToken,
            outputKey: \ListFlowAssociationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listFlowAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - resourceType: A valid resource type.
    ///   - logger: Logger used for logging
    @inlinable
    public func listFlowAssociationsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        resourceType: ListFlowAssociationResourceType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListFlowAssociationsRequest, ListFlowAssociationsResponse> {
        let input = ListFlowAssociationsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            resourceType: resourceType
        )
        return self.listFlowAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listHoursOfOperationOverrides(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listHoursOfOperationOverridesPaginator(
        _ input: ListHoursOfOperationOverridesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListHoursOfOperationOverridesRequest, ListHoursOfOperationOverridesResponse> {
        return .init(
            input: input,
            command: self.listHoursOfOperationOverrides,
            inputKey: \ListHoursOfOperationOverridesRequest.nextToken,
            outputKey: \ListHoursOfOperationOverridesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listHoursOfOperationOverrides(_:logger:)``.
    ///
    /// - Parameters:
    ///   - hoursOfOperationId: The identifier for the hours of operation
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100. Valid Range: Minimum value of 1. Maximum value of 1000.
    ///   - logger: Logger used for logging
    @inlinable
    public func listHoursOfOperationOverridesPaginator(
        hoursOfOperationId: String,
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListHoursOfOperationOverridesRequest, ListHoursOfOperationOverridesResponse> {
        let input = ListHoursOfOperationOverridesRequest(
            hoursOfOperationId: hoursOfOperationId, 
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listHoursOfOperationOverridesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listHoursOfOperations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listHoursOfOperationsPaginator(
        _ input: ListHoursOfOperationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListHoursOfOperationsRequest, ListHoursOfOperationsResponse> {
        return .init(
            input: input,
            command: self.listHoursOfOperations,
            inputKey: \ListHoursOfOperationsRequest.nextToken,
            outputKey: \ListHoursOfOperationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listHoursOfOperations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func listHoursOfOperationsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListHoursOfOperationsRequest, ListHoursOfOperationsResponse> {
        let input = ListHoursOfOperationsRequest(
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listHoursOfOperationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listInstanceAttributes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listInstanceAttributesPaginator(
        _ input: ListInstanceAttributesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListInstanceAttributesRequest, ListInstanceAttributesResponse> {
        return .init(
            input: input,
            command: self.listInstanceAttributes,
            inputKey: \ListInstanceAttributesRequest.nextToken,
            outputKey: \ListInstanceAttributesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listInstanceAttributes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listInstanceAttributesPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListInstanceAttributesRequest, ListInstanceAttributesResponse> {
        let input = ListInstanceAttributesRequest(
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listInstanceAttributesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listInstanceStorageConfigs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listInstanceStorageConfigsPaginator(
        _ input: ListInstanceStorageConfigsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListInstanceStorageConfigsRequest, ListInstanceStorageConfigsResponse> {
        return .init(
            input: input,
            command: self.listInstanceStorageConfigs,
            inputKey: \ListInstanceStorageConfigsRequest.nextToken,
            outputKey: \ListInstanceStorageConfigsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listInstanceStorageConfigs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - resourceType: A valid resource type.
    ///   - logger: Logger used for logging
    @inlinable
    public func listInstanceStorageConfigsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        resourceType: InstanceStorageResourceType,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListInstanceStorageConfigsRequest, ListInstanceStorageConfigsResponse> {
        let input = ListInstanceStorageConfigsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            resourceType: resourceType
        )
        return self.listInstanceStorageConfigsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listInstancesPaginator(
        _ input: ListInstancesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListInstancesRequest, ListInstancesResponse> {
        return .init(
            input: input,
            command: self.listInstances,
            inputKey: \ListInstancesRequest.nextToken,
            outputKey: \ListInstancesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listInstancesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListInstancesRequest, ListInstancesResponse> {
        let input = ListInstancesRequest(
            maxResults: maxResults
        )
        return self.listInstancesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listIntegrationAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listIntegrationAssociationsPaginator(
        _ input: ListIntegrationAssociationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListIntegrationAssociationsRequest, ListIntegrationAssociationsResponse> {
        return .init(
            input: input,
            command: self.listIntegrationAssociations,
            inputKey: \ListIntegrationAssociationsRequest.nextToken,
            outputKey: \ListIntegrationAssociationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listIntegrationAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - integrationArn: The Amazon Resource Name (ARN) of the integration.
    ///   - integrationType: The integration type.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listIntegrationAssociationsPaginator(
        instanceId: String,
        integrationArn: String? = nil,
        integrationType: IntegrationType? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListIntegrationAssociationsRequest, ListIntegrationAssociationsResponse> {
        let input = ListIntegrationAssociationsRequest(
            instanceId: instanceId, 
            integrationArn: integrationArn, 
            integrationType: integrationType, 
            maxResults: maxResults
        )
        return self.listIntegrationAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listLambdaFunctions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listLambdaFunctionsPaginator(
        _ input: ListLambdaFunctionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListLambdaFunctionsRequest, ListLambdaFunctionsResponse> {
        return .init(
            input: input,
            command: self.listLambdaFunctions,
            inputKey: \ListLambdaFunctionsRequest.nextToken,
            outputKey: \ListLambdaFunctionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listLambdaFunctions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listLambdaFunctionsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListLambdaFunctionsRequest, ListLambdaFunctionsResponse> {
        let input = ListLambdaFunctionsRequest(
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listLambdaFunctionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listLexBots(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listLexBotsPaginator(
        _ input: ListLexBotsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListLexBotsRequest, ListLexBotsResponse> {
        return .init(
            input: input,
            command: self.listLexBots,
            inputKey: \ListLexBotsRequest.nextToken,
            outputKey: \ListLexBotsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listLexBots(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. If no value is specified, the default is 10.
    ///   - logger: Logger used for logging
    @inlinable
    public func listLexBotsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListLexBotsRequest, ListLexBotsResponse> {
        let input = ListLexBotsRequest(
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listLexBotsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPhoneNumbers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPhoneNumbersPaginator(
        _ input: ListPhoneNumbersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPhoneNumbersRequest, ListPhoneNumbersResponse> {
        return .init(
            input: input,
            command: self.listPhoneNumbers,
            inputKey: \ListPhoneNumbersRequest.nextToken,
            outputKey: \ListPhoneNumbersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPhoneNumbers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - phoneNumberCountryCodes: The ISO country code.
    ///   - phoneNumberTypes: The type of phone number.  We recommend using ListPhoneNumbersV2 to return phone number types. While ListPhoneNumbers returns number types UIFN, SHARED, THIRD_PARTY_TF, and THIRD_PARTY_DID, it incorrectly lists them as TOLL_FREE or DID.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPhoneNumbersPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        phoneNumberCountryCodes: [PhoneNumberCountryCode]? = nil,
        phoneNumberTypes: [PhoneNumberType]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPhoneNumbersRequest, ListPhoneNumbersResponse> {
        let input = ListPhoneNumbersRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            phoneNumberCountryCodes: phoneNumberCountryCodes, 
            phoneNumberTypes: phoneNumberTypes
        )
        return self.listPhoneNumbersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPhoneNumbersV2(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPhoneNumbersV2Paginator(
        _ input: ListPhoneNumbersV2Request,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPhoneNumbersV2Request, ListPhoneNumbersV2Response> {
        return .init(
            input: input,
            command: self.listPhoneNumbersV2,
            inputKey: \ListPhoneNumbersV2Request.nextToken,
            outputKey: \ListPhoneNumbersV2Response.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPhoneNumbersV2(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance that phone numbers are claimed to. You can find the instance ID in the Amazon Resource Name (ARN) of the instance. If both TargetArn and InstanceId are not provided, this API lists numbers claimed to all the Amazon Connect instances belonging to your account in the same AWS Region as the request.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - phoneNumberCountryCodes: The ISO country code.
    ///   - phoneNumberPrefix: The prefix of the phone number. If provided, it must contain + as part of the country code.
    ///   - phoneNumberTypes: The type of phone number.
    ///   - targetArn: The Amazon Resource Name (ARN) for Amazon Connect instances or traffic distribution groups that phone number inbound traffic is routed through. If both TargetArn and InstanceId input are not provided, this API lists numbers claimed to all the Amazon Connect instances belonging to your account in the same Amazon Web Services Region as the request.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPhoneNumbersV2Paginator(
        instanceId: String? = nil,
        maxResults: Int? = nil,
        phoneNumberCountryCodes: [PhoneNumberCountryCode]? = nil,
        phoneNumberPrefix: String? = nil,
        phoneNumberTypes: [PhoneNumberType]? = nil,
        targetArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPhoneNumbersV2Request, ListPhoneNumbersV2Response> {
        let input = ListPhoneNumbersV2Request(
            instanceId: instanceId, 
            maxResults: maxResults, 
            phoneNumberCountryCodes: phoneNumberCountryCodes, 
            phoneNumberPrefix: phoneNumberPrefix, 
            phoneNumberTypes: phoneNumberTypes, 
            targetArn: targetArn
        )
        return self.listPhoneNumbersV2Paginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPredefinedAttributes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPredefinedAttributesPaginator(
        _ input: ListPredefinedAttributesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPredefinedAttributesRequest, ListPredefinedAttributesResponse> {
        return .init(
            input: input,
            command: self.listPredefinedAttributes,
            inputKey: \ListPredefinedAttributesRequest.nextToken,
            outputKey: \ListPredefinedAttributesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPredefinedAttributes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPredefinedAttributesPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPredefinedAttributesRequest, ListPredefinedAttributesResponse> {
        let input = ListPredefinedAttributesRequest(
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listPredefinedAttributesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPrompts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPromptsPaginator(
        _ input: ListPromptsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPromptsRequest, ListPromptsResponse> {
        return .init(
            input: input,
            command: self.listPrompts,
            inputKey: \ListPromptsRequest.nextToken,
            outputKey: \ListPromptsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPrompts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPromptsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPromptsRequest, ListPromptsResponse> {
        let input = ListPromptsRequest(
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listPromptsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listQueueQuickConnects(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listQueueQuickConnectsPaginator(
        _ input: ListQueueQuickConnectsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListQueueQuickConnectsRequest, ListQueueQuickConnectsResponse> {
        return .init(
            input: input,
            command: self.listQueueQuickConnects,
            inputKey: \ListQueueQuickConnectsRequest.nextToken,
            outputKey: \ListQueueQuickConnectsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listQueueQuickConnects(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - queueId: The identifier for the queue.
    ///   - logger: Logger used for logging
    @inlinable
    public func listQueueQuickConnectsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        queueId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListQueueQuickConnectsRequest, ListQueueQuickConnectsResponse> {
        let input = ListQueueQuickConnectsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            queueId: queueId
        )
        return self.listQueueQuickConnectsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listQueues(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listQueuesPaginator(
        _ input: ListQueuesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListQueuesRequest, ListQueuesResponse> {
        return .init(
            input: input,
            command: self.listQueues,
            inputKey: \ListQueuesRequest.nextToken,
            outputKey: \ListQueuesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listQueues(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - queueTypes: The type of queue.
    ///   - logger: Logger used for logging
    @inlinable
    public func listQueuesPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        queueTypes: [QueueType]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListQueuesRequest, ListQueuesResponse> {
        let input = ListQueuesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            queueTypes: queueTypes
        )
        return self.listQueuesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listQuickConnects(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listQuickConnectsPaginator(
        _ input: ListQuickConnectsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListQuickConnectsRequest, ListQuickConnectsResponse> {
        return .init(
            input: input,
            command: self.listQuickConnects,
            inputKey: \ListQuickConnectsRequest.nextToken,
            outputKey: \ListQuickConnectsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listQuickConnects(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - quickConnectTypes: The type of quick connect. In the Amazon Connect admin website, when you create a quick connect, you are prompted to assign one of the following types: Agent (USER), External (PHONE_NUMBER), or Queue (QUEUE).
    ///   - logger: Logger used for logging
    @inlinable
    public func listQuickConnectsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        quickConnectTypes: [QuickConnectType]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListQuickConnectsRequest, ListQuickConnectsResponse> {
        let input = ListQuickConnectsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            quickConnectTypes: quickConnectTypes
        )
        return self.listQuickConnectsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRealtimeContactAnalysisSegmentsV2(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRealtimeContactAnalysisSegmentsV2Paginator(
        _ input: ListRealtimeContactAnalysisSegmentsV2Request,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRealtimeContactAnalysisSegmentsV2Request, ListRealtimeContactAnalysisSegmentsV2Response> {
        return .init(
            input: input,
            command: self.listRealtimeContactAnalysisSegmentsV2,
            inputKey: \ListRealtimeContactAnalysisSegmentsV2Request.nextToken,
            outputKey: \ListRealtimeContactAnalysisSegmentsV2Response.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRealtimeContactAnalysisSegmentsV2(_:logger:)``.
    ///
    /// - Parameters:
    ///   - contactId: The identifier of the contact in this instance of Amazon Connect.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - outputType: The Contact Lens output type to be returned.
    ///   - segmentTypes: Enum with segment types . Each value corresponds to a segment type returned in the segments list of the API. Each segment type has its own structure. Different channels may have different sets of supported segment types.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRealtimeContactAnalysisSegmentsV2Paginator(
        contactId: String,
        instanceId: String,
        maxResults: Int? = nil,
        outputType: RealTimeContactAnalysisOutputType,
        segmentTypes: [RealTimeContactAnalysisSegmentType],
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRealtimeContactAnalysisSegmentsV2Request, ListRealtimeContactAnalysisSegmentsV2Response> {
        let input = ListRealtimeContactAnalysisSegmentsV2Request(
            contactId: contactId, 
            instanceId: instanceId, 
            maxResults: maxResults, 
            outputType: outputType, 
            segmentTypes: segmentTypes
        )
        return self.listRealtimeContactAnalysisSegmentsV2Paginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRoutingProfileQueues(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRoutingProfileQueuesPaginator(
        _ input: ListRoutingProfileQueuesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRoutingProfileQueuesRequest, ListRoutingProfileQueuesResponse> {
        return .init(
            input: input,
            command: self.listRoutingProfileQueues,
            inputKey: \ListRoutingProfileQueuesRequest.nextToken,
            outputKey: \ListRoutingProfileQueuesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRoutingProfileQueues(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - routingProfileId: The identifier of the routing profile.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRoutingProfileQueuesPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        routingProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRoutingProfileQueuesRequest, ListRoutingProfileQueuesResponse> {
        let input = ListRoutingProfileQueuesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            routingProfileId: routingProfileId
        )
        return self.listRoutingProfileQueuesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRoutingProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRoutingProfilesPaginator(
        _ input: ListRoutingProfilesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRoutingProfilesRequest, ListRoutingProfilesResponse> {
        return .init(
            input: input,
            command: self.listRoutingProfiles,
            inputKey: \ListRoutingProfilesRequest.nextToken,
            outputKey: \ListRoutingProfilesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRoutingProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRoutingProfilesPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRoutingProfilesRequest, ListRoutingProfilesResponse> {
        let input = ListRoutingProfilesRequest(
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listRoutingProfilesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRules(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRulesPaginator(
        _ input: ListRulesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRulesRequest, ListRulesResponse> {
        return .init(
            input: input,
            command: self.listRules,
            inputKey: \ListRulesRequest.nextToken,
            outputKey: \ListRulesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRules(_:logger:)``.
    ///
    /// - Parameters:
    ///   - eventSourceName: The name of the event source.
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - publishStatus: The publish status of the rule.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRulesPaginator(
        eventSourceName: EventSourceName? = nil,
        instanceId: String,
        maxResults: Int? = nil,
        publishStatus: RulePublishStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRulesRequest, ListRulesResponse> {
        let input = ListRulesRequest(
            eventSourceName: eventSourceName, 
            instanceId: instanceId, 
            maxResults: maxResults, 
            publishStatus: publishStatus
        )
        return self.listRulesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSecurityKeys(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSecurityKeysPaginator(
        _ input: ListSecurityKeysRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSecurityKeysRequest, ListSecurityKeysResponse> {
        return .init(
            input: input,
            command: self.listSecurityKeys,
            inputKey: \ListSecurityKeysRequest.nextToken,
            outputKey: \ListSecurityKeysResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSecurityKeys(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSecurityKeysPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSecurityKeysRequest, ListSecurityKeysResponse> {
        let input = ListSecurityKeysRequest(
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listSecurityKeysPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSecurityProfileApplications(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSecurityProfileApplicationsPaginator(
        _ input: ListSecurityProfileApplicationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSecurityProfileApplicationsRequest, ListSecurityProfileApplicationsResponse> {
        return .init(
            input: input,
            command: self.listSecurityProfileApplications,
            inputKey: \ListSecurityProfileApplicationsRequest.nextToken,
            outputKey: \ListSecurityProfileApplicationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSecurityProfileApplications(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - securityProfileId: The identifier for the security profle.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSecurityProfileApplicationsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        securityProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSecurityProfileApplicationsRequest, ListSecurityProfileApplicationsResponse> {
        let input = ListSecurityProfileApplicationsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            securityProfileId: securityProfileId
        )
        return self.listSecurityProfileApplicationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSecurityProfilePermissions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSecurityProfilePermissionsPaginator(
        _ input: ListSecurityProfilePermissionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSecurityProfilePermissionsRequest, ListSecurityProfilePermissionsResponse> {
        return .init(
            input: input,
            command: self.listSecurityProfilePermissions,
            inputKey: \ListSecurityProfilePermissionsRequest.nextToken,
            outputKey: \ListSecurityProfilePermissionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSecurityProfilePermissions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - securityProfileId: The identifier for the security profle.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSecurityProfilePermissionsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        securityProfileId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSecurityProfilePermissionsRequest, ListSecurityProfilePermissionsResponse> {
        let input = ListSecurityProfilePermissionsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            securityProfileId: securityProfileId
        )
        return self.listSecurityProfilePermissionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSecurityProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSecurityProfilesPaginator(
        _ input: ListSecurityProfilesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSecurityProfilesRequest, ListSecurityProfilesResponse> {
        return .init(
            input: input,
            command: self.listSecurityProfiles,
            inputKey: \ListSecurityProfilesRequest.nextToken,
            outputKey: \ListSecurityProfilesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSecurityProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSecurityProfilesPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSecurityProfilesRequest, ListSecurityProfilesResponse> {
        let input = ListSecurityProfilesRequest(
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listSecurityProfilesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listTaskTemplates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listTaskTemplatesPaginator(
        _ input: ListTaskTemplatesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListTaskTemplatesRequest, ListTaskTemplatesResponse> {
        return .init(
            input: input,
            command: self.listTaskTemplates,
            inputKey: \ListTaskTemplatesRequest.nextToken,
            outputKey: \ListTaskTemplatesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listTaskTemplates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.  It is not expected that you set this.
    ///   - name: The name of the task template.
    ///   - status: Marks a template as ACTIVE or INACTIVE for a task to refer to it.
    ///   - logger: Logger used for logging
    @inlinable
    public func listTaskTemplatesPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        name: String? = nil,
        status: TaskTemplateStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListTaskTemplatesRequest, ListTaskTemplatesResponse> {
        let input = ListTaskTemplatesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            name: name, 
            status: status
        )
        return self.listTaskTemplatesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listTrafficDistributionGroupUsers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listTrafficDistributionGroupUsersPaginator(
        _ input: ListTrafficDistributionGroupUsersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListTrafficDistributionGroupUsersRequest, ListTrafficDistributionGroupUsersResponse> {
        return .init(
            input: input,
            command: self.listTrafficDistributionGroupUsers,
            inputKey: \ListTrafficDistributionGroupUsersRequest.nextToken,
            outputKey: \ListTrafficDistributionGroupUsersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listTrafficDistributionGroupUsers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return per page.
    ///   - trafficDistributionGroupId: The identifier of the traffic distribution group.
    ///   - logger: Logger used for logging
    @inlinable
    public func listTrafficDistributionGroupUsersPaginator(
        maxResults: Int? = nil,
        trafficDistributionGroupId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListTrafficDistributionGroupUsersRequest, ListTrafficDistributionGroupUsersResponse> {
        let input = ListTrafficDistributionGroupUsersRequest(
            maxResults: maxResults, 
            trafficDistributionGroupId: trafficDistributionGroupId
        )
        return self.listTrafficDistributionGroupUsersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listTrafficDistributionGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listTrafficDistributionGroupsPaginator(
        _ input: ListTrafficDistributionGroupsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListTrafficDistributionGroupsRequest, ListTrafficDistributionGroupsResponse> {
        return .init(
            input: input,
            command: self.listTrafficDistributionGroups,
            inputKey: \ListTrafficDistributionGroupsRequest.nextToken,
            outputKey: \ListTrafficDistributionGroupsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listTrafficDistributionGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listTrafficDistributionGroupsPaginator(
        instanceId: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListTrafficDistributionGroupsRequest, ListTrafficDistributionGroupsResponse> {
        let input = ListTrafficDistributionGroupsRequest(
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listTrafficDistributionGroupsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listUseCases(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listUseCasesPaginator(
        _ input: ListUseCasesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListUseCasesRequest, ListUseCasesResponse> {
        return .init(
            input: input,
            command: self.listUseCases,
            inputKey: \ListUseCasesRequest.nextToken,
            outputKey: \ListUseCasesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listUseCases(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - integrationAssociationId: The identifier for the integration association.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - logger: Logger used for logging
    @inlinable
    public func listUseCasesPaginator(
        instanceId: String,
        integrationAssociationId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListUseCasesRequest, ListUseCasesResponse> {
        let input = ListUseCasesRequest(
            instanceId: instanceId, 
            integrationAssociationId: integrationAssociationId, 
            maxResults: maxResults
        )
        return self.listUseCasesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listUserHierarchyGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listUserHierarchyGroupsPaginator(
        _ input: ListUserHierarchyGroupsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListUserHierarchyGroupsRequest, ListUserHierarchyGroupsResponse> {
        return .init(
            input: input,
            command: self.listUserHierarchyGroups,
            inputKey: \ListUserHierarchyGroupsRequest.nextToken,
            outputKey: \ListUserHierarchyGroupsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listUserHierarchyGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func listUserHierarchyGroupsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListUserHierarchyGroupsRequest, ListUserHierarchyGroupsResponse> {
        let input = ListUserHierarchyGroupsRequest(
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listUserHierarchyGroupsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listUserProficiencies(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listUserProficienciesPaginator(
        _ input: ListUserProficienciesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListUserProficienciesRequest, ListUserProficienciesResponse> {
        return .init(
            input: input,
            command: self.listUserProficiencies,
            inputKey: \ListUserProficienciesRequest.nextToken,
            outputKey: \ListUserProficienciesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listUserProficiencies(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - userId: The identifier of the user account.
    ///   - logger: Logger used for logging
    @inlinable
    public func listUserProficienciesPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListUserProficienciesRequest, ListUserProficienciesResponse> {
        let input = ListUserProficienciesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            userId: userId
        )
        return self.listUserProficienciesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listUsers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listUsersPaginator(
        _ input: ListUsersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListUsersRequest, ListUsersResponse> {
        return .init(
            input: input,
            command: self.listUsers,
            inputKey: \ListUsersRequest.nextToken,
            outputKey: \ListUsersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listUsers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func listUsersPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListUsersRequest, ListUsersResponse> {
        let input = ListUsersRequest(
            instanceId: instanceId, 
            maxResults: maxResults
        )
        return self.listUsersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listViewVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listViewVersionsPaginator(
        _ input: ListViewVersionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListViewVersionsRequest, ListViewVersionsResponse> {
        return .init(
            input: input,
            command: self.listViewVersions,
            inputKey: \ListViewVersionsRequest.nextToken,
            outputKey: \ListViewVersionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listViewVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - viewId: The identifier of the view. Both ViewArn and ViewId can be used.
    ///   - logger: Logger used for logging
    @inlinable
    public func listViewVersionsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        viewId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListViewVersionsRequest, ListViewVersionsResponse> {
        let input = ListViewVersionsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            viewId: viewId
        )
        return self.listViewVersionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listViews(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listViewsPaginator(
        _ input: ListViewsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListViewsRequest, ListViewsResponse> {
        return .init(
            input: input,
            command: self.listViews,
            inputKey: \ListViewsRequest.nextToken,
            outputKey: \ListViewsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listViews(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - maxResults: The maximum number of results to return per page. The default MaxResult size is 100.
    ///   - type: The type of the view.
    ///   - logger: Logger used for logging
    @inlinable
    public func listViewsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        type: ViewType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListViewsRequest, ListViewsResponse> {
        let input = ListViewsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            type: type
        )
        return self.listViewsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchAgentStatuses(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchAgentStatusesPaginator(
        _ input: SearchAgentStatusesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchAgentStatusesRequest, SearchAgentStatusesResponse> {
        return .init(
            input: input,
            command: self.searchAgentStatuses,
            inputKey: \SearchAgentStatusesRequest.nextToken,
            outputKey: \SearchAgentStatusesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchAgentStatuses(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - searchCriteria: The search criteria to be used to return agent statuses.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchAgentStatusesPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        searchCriteria: AgentStatusSearchCriteria? = nil,
        searchFilter: AgentStatusSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchAgentStatusesRequest, SearchAgentStatusesResponse> {
        let input = SearchAgentStatusesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return self.searchAgentStatusesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchAvailablePhoneNumbers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchAvailablePhoneNumbersPaginator(
        _ input: SearchAvailablePhoneNumbersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchAvailablePhoneNumbersRequest, SearchAvailablePhoneNumbersResponse> {
        return .init(
            input: input,
            command: self.searchAvailablePhoneNumbers,
            inputKey: \SearchAvailablePhoneNumbersRequest.nextToken,
            outputKey: \SearchAvailablePhoneNumbersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchAvailablePhoneNumbers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance that phone numbers are claimed to. You can find the instance ID in the Amazon Resource Name (ARN) of the instance. You must enter InstanceId or TargetArn.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - phoneNumberCountryCode: The ISO country code.
    ///   - phoneNumberPrefix: The prefix of the phone number. If provided, it must contain + as part of the country code.
    ///   - phoneNumberType: The type of phone number.
    ///   - targetArn: The Amazon Resource Name (ARN) for Amazon Connect instances or traffic distribution groups that phone number inbound traffic is routed through. You must enter InstanceId or TargetArn.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchAvailablePhoneNumbersPaginator(
        instanceId: String? = nil,
        maxResults: Int? = nil,
        phoneNumberCountryCode: PhoneNumberCountryCode,
        phoneNumberPrefix: String? = nil,
        phoneNumberType: PhoneNumberType,
        targetArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchAvailablePhoneNumbersRequest, SearchAvailablePhoneNumbersResponse> {
        let input = SearchAvailablePhoneNumbersRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            phoneNumberCountryCode: phoneNumberCountryCode, 
            phoneNumberPrefix: phoneNumberPrefix, 
            phoneNumberType: phoneNumberType, 
            targetArn: targetArn
        )
        return self.searchAvailablePhoneNumbersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchContactFlowModules(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchContactFlowModulesPaginator(
        _ input: SearchContactFlowModulesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchContactFlowModulesRequest, SearchContactFlowModulesResponse> {
        return .init(
            input: input,
            command: self.searchContactFlowModules,
            inputKey: \SearchContactFlowModulesRequest.nextToken,
            outputKey: \SearchContactFlowModulesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchContactFlowModules(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - searchCriteria: The search criteria to be used to return flow modules.  The name and description fields support "contains" queries with a minimum of 2 characters and a maximum of 25 characters. Any queries with character lengths outside of this range will result in invalid results.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchContactFlowModulesPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        searchCriteria: ContactFlowModuleSearchCriteria? = nil,
        searchFilter: ContactFlowModuleSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchContactFlowModulesRequest, SearchContactFlowModulesResponse> {
        let input = SearchContactFlowModulesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return self.searchContactFlowModulesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchContactFlows(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchContactFlowsPaginator(
        _ input: SearchContactFlowsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchContactFlowsRequest, SearchContactFlowsResponse> {
        return .init(
            input: input,
            command: self.searchContactFlows,
            inputKey: \SearchContactFlowsRequest.nextToken,
            outputKey: \SearchContactFlowsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchContactFlows(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - searchCriteria: The search criteria to be used to return flows.  The name and description fields support "contains" queries with a minimum of 2 characters and a maximum of 25 characters. Any queries with character lengths outside of this range will result in invalid results.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchContactFlowsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        searchCriteria: ContactFlowSearchCriteria? = nil,
        searchFilter: ContactFlowSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchContactFlowsRequest, SearchContactFlowsResponse> {
        let input = SearchContactFlowsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return self.searchContactFlowsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchContacts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchContactsPaginator(
        _ input: SearchContactsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchContactsRequest, SearchContactsResponse> {
        return .init(
            input: input,
            command: self.searchContacts,
            inputKey: \SearchContactsRequest.nextToken,
            outputKey: \SearchContactsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchContacts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - searchCriteria: The search criteria to be used to return contacts.
    ///   - sort: Specifies a field to sort by and a sort order.
    ///   - timeRange: Time range that you want to search results.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchContactsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        searchCriteria: SearchCriteria? = nil,
        sort: Sort? = nil,
        timeRange: SearchContactsTimeRange,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchContactsRequest, SearchContactsResponse> {
        let input = SearchContactsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            searchCriteria: searchCriteria, 
            sort: sort, 
            timeRange: timeRange
        )
        return self.searchContactsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchHoursOfOperationOverrides(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchHoursOfOperationOverridesPaginator(
        _ input: SearchHoursOfOperationOverridesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchHoursOfOperationOverridesRequest, SearchHoursOfOperationOverridesResponse> {
        return .init(
            input: input,
            command: self.searchHoursOfOperationOverrides,
            inputKey: \SearchHoursOfOperationOverridesRequest.nextToken,
            outputKey: \SearchHoursOfOperationOverridesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchHoursOfOperationOverrides(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance.
    ///   - maxResults: The maximum number of results to return per page. Valid Range: Minimum value of 1. Maximum value of 100.
    ///   - searchCriteria: The search criteria to be used to return hours of operations overrides.
    ///   - searchFilter: 
    ///   - logger: Logger used for logging
    @inlinable
    public func searchHoursOfOperationOverridesPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        searchCriteria: HoursOfOperationOverrideSearchCriteria? = nil,
        searchFilter: HoursOfOperationSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchHoursOfOperationOverridesRequest, SearchHoursOfOperationOverridesResponse> {
        let input = SearchHoursOfOperationOverridesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return self.searchHoursOfOperationOverridesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchHoursOfOperations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchHoursOfOperationsPaginator(
        _ input: SearchHoursOfOperationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchHoursOfOperationsRequest, SearchHoursOfOperationsResponse> {
        return .init(
            input: input,
            command: self.searchHoursOfOperations,
            inputKey: \SearchHoursOfOperationsRequest.nextToken,
            outputKey: \SearchHoursOfOperationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchHoursOfOperations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - searchCriteria: The search criteria to be used to return hours of operations.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchHoursOfOperationsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        searchCriteria: HoursOfOperationSearchCriteria? = nil,
        searchFilter: HoursOfOperationSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchHoursOfOperationsRequest, SearchHoursOfOperationsResponse> {
        let input = SearchHoursOfOperationsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return self.searchHoursOfOperationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchPredefinedAttributes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchPredefinedAttributesPaginator(
        _ input: SearchPredefinedAttributesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchPredefinedAttributesRequest, SearchPredefinedAttributesResponse> {
        return .init(
            input: input,
            command: self.searchPredefinedAttributes,
            inputKey: \SearchPredefinedAttributesRequest.nextToken,
            outputKey: \SearchPredefinedAttributesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchPredefinedAttributes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - searchCriteria: The search criteria to be used to return predefined attributes.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchPredefinedAttributesPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        searchCriteria: PredefinedAttributeSearchCriteria? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchPredefinedAttributesRequest, SearchPredefinedAttributesResponse> {
        let input = SearchPredefinedAttributesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            searchCriteria: searchCriteria
        )
        return self.searchPredefinedAttributesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchPrompts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchPromptsPaginator(
        _ input: SearchPromptsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchPromptsRequest, SearchPromptsResponse> {
        return .init(
            input: input,
            command: self.searchPrompts,
            inputKey: \SearchPromptsRequest.nextToken,
            outputKey: \SearchPromptsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchPrompts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - searchCriteria: The search criteria to be used to return prompts.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchPromptsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        searchCriteria: PromptSearchCriteria? = nil,
        searchFilter: PromptSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchPromptsRequest, SearchPromptsResponse> {
        let input = SearchPromptsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return self.searchPromptsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchQueues(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchQueuesPaginator(
        _ input: SearchQueuesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchQueuesRequest, SearchQueuesResponse> {
        return .init(
            input: input,
            command: self.searchQueues,
            inputKey: \SearchQueuesRequest.nextToken,
            outputKey: \SearchQueuesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchQueues(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - searchCriteria: The search criteria to be used to return queues.  The name and description fields support "contains" queries with a minimum of 2 characters and a maximum of 25 characters. Any queries with character lengths outside of this range will throw invalid results.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchQueuesPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        searchCriteria: QueueSearchCriteria? = nil,
        searchFilter: QueueSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchQueuesRequest, SearchQueuesResponse> {
        let input = SearchQueuesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return self.searchQueuesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchQuickConnects(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchQuickConnectsPaginator(
        _ input: SearchQuickConnectsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchQuickConnectsRequest, SearchQuickConnectsResponse> {
        return .init(
            input: input,
            command: self.searchQuickConnects,
            inputKey: \SearchQuickConnectsRequest.nextToken,
            outputKey: \SearchQuickConnectsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchQuickConnects(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - searchCriteria: The search criteria to be used to return quick connects.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchQuickConnectsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        searchCriteria: QuickConnectSearchCriteria? = nil,
        searchFilter: QuickConnectSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchQuickConnectsRequest, SearchQuickConnectsResponse> {
        let input = SearchQuickConnectsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return self.searchQuickConnectsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchResourceTags(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchResourceTagsPaginator(
        _ input: SearchResourceTagsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchResourceTagsRequest, SearchResourceTagsResponse> {
        return .init(
            input: input,
            command: self.searchResourceTags,
            inputKey: \SearchResourceTagsRequest.nextToken,
            outputKey: \SearchResourceTagsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchResourceTags(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - resourceTypes: The list of resource types to be used to search tags from. If not provided or if any empty list is provided, this API will search from all supported resource types. Note that lowercase and - are required.  Supported resource types    agent   agent-state   routing-profile   standard-queue   security-profile   operating-hours   prompt   contact-flow   flow- module   transfer-destination (also known as quick connect)
    ///   - searchCriteria: The search criteria to be used to return tags.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchResourceTagsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        resourceTypes: [String]? = nil,
        searchCriteria: ResourceTagsSearchCriteria? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchResourceTagsRequest, SearchResourceTagsResponse> {
        let input = SearchResourceTagsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            resourceTypes: resourceTypes, 
            searchCriteria: searchCriteria
        )
        return self.searchResourceTagsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchRoutingProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchRoutingProfilesPaginator(
        _ input: SearchRoutingProfilesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchRoutingProfilesRequest, SearchRoutingProfilesResponse> {
        return .init(
            input: input,
            command: self.searchRoutingProfiles,
            inputKey: \SearchRoutingProfilesRequest.nextToken,
            outputKey: \SearchRoutingProfilesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchRoutingProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - searchCriteria: The search criteria to be used to return routing profiles.  The name and description fields support "contains" queries with a minimum of 2 characters and a maximum of 25 characters. Any queries with character lengths outside of this range will throw invalid results.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchRoutingProfilesPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        searchCriteria: RoutingProfileSearchCriteria? = nil,
        searchFilter: RoutingProfileSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchRoutingProfilesRequest, SearchRoutingProfilesResponse> {
        let input = SearchRoutingProfilesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return self.searchRoutingProfilesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchSecurityProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchSecurityProfilesPaginator(
        _ input: SearchSecurityProfilesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchSecurityProfilesRequest, SearchSecurityProfilesResponse> {
        return .init(
            input: input,
            command: self.searchSecurityProfiles,
            inputKey: \SearchSecurityProfilesRequest.nextToken,
            outputKey: \SearchSecurityProfilesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchSecurityProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - searchCriteria: The search criteria to be used to return security profiles.   The name field support "contains" queries with a minimum of 2 characters and maximum of 25 characters. Any queries with character lengths outside of this range will throw invalid results.   The currently supported value for FieldName: name
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchSecurityProfilesPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        searchCriteria: SecurityProfileSearchCriteria? = nil,
        searchFilter: SecurityProfilesSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchSecurityProfilesRequest, SearchSecurityProfilesResponse> {
        let input = SearchSecurityProfilesRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return self.searchSecurityProfilesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchUserHierarchyGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchUserHierarchyGroupsPaginator(
        _ input: SearchUserHierarchyGroupsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchUserHierarchyGroupsRequest, SearchUserHierarchyGroupsResponse> {
        return .init(
            input: input,
            command: self.searchUserHierarchyGroups,
            inputKey: \SearchUserHierarchyGroupsRequest.nextToken,
            outputKey: \SearchUserHierarchyGroupsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchUserHierarchyGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instanceId in the ARN of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - searchCriteria: The search criteria to be used to return UserHierarchyGroups.
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchUserHierarchyGroupsPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        searchCriteria: UserHierarchyGroupSearchCriteria? = nil,
        searchFilter: UserHierarchyGroupSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchUserHierarchyGroupsRequest, SearchUserHierarchyGroupsResponse> {
        let input = SearchUserHierarchyGroupsRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return self.searchUserHierarchyGroupsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchUsers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchUsersPaginator(
        _ input: SearchUsersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchUsersRequest, SearchUsersResponse> {
        return .init(
            input: input,
            command: self.searchUsers,
            inputKey: \SearchUsersRequest.nextToken,
            outputKey: \SearchUsersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchUsers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - maxResults: The maximum number of results to return per page.
    ///   - searchCriteria: 
    ///   - searchFilter: Filters to be applied to search results.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchUsersPaginator(
        instanceId: String,
        maxResults: Int? = nil,
        searchCriteria: UserSearchCriteria? = nil,
        searchFilter: UserSearchFilter? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchUsersRequest, SearchUsersResponse> {
        let input = SearchUsersRequest(
            instanceId: instanceId, 
            maxResults: maxResults, 
            searchCriteria: searchCriteria, 
            searchFilter: searchFilter
        )
        return self.searchUsersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchVocabularies(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchVocabulariesPaginator(
        _ input: SearchVocabulariesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchVocabulariesRequest, SearchVocabulariesResponse> {
        return .init(
            input: input,
            command: self.searchVocabularies,
            inputKey: \SearchVocabulariesRequest.nextToken,
            outputKey: \SearchVocabulariesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchVocabularies(_:logger:)``.
    ///
    /// - Parameters:
    ///   - instanceId: The identifier of the Amazon Connect instance. You can find the instance ID in the Amazon Resource Name (ARN) of the instance.
    ///   - languageCode: The language code of the vocabulary entries. For a list of languages and their corresponding language codes, see
    ///   - maxResults: The maximum number of results to return per page.
    ///   - nameStartsWith: The starting pattern of the name of the vocabulary.
    ///   - state: The current state of the custom vocabulary.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchVocabulariesPaginator(
        instanceId: String,
        languageCode: VocabularyLanguageCode? = nil,
        maxResults: Int? = nil,
        nameStartsWith: String? = nil,
        state: VocabularyState? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchVocabulariesRequest, SearchVocabulariesResponse> {
        let input = SearchVocabulariesRequest(
            instanceId: instanceId, 
            languageCode: languageCode, 
            maxResults: maxResults, 
            nameStartsWith: nameStartsWith, 
            state: state
        )
        return self.searchVocabulariesPaginator(input, logger: logger)
    }
}

extension Connect.GetCurrentMetricDataRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.GetCurrentMetricDataRequest {
        return .init(
            currentMetrics: self.currentMetrics,
            filters: self.filters,
            groupings: self.groupings,
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            sortCriteria: self.sortCriteria
        )
    }
}

extension Connect.GetCurrentUserDataRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.GetCurrentUserDataRequest {
        return .init(
            filters: self.filters,
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.GetMetricDataRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.GetMetricDataRequest {
        return .init(
            endTime: self.endTime,
            filters: self.filters,
            groupings: self.groupings,
            historicalMetrics: self.historicalMetrics,
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            startTime: self.startTime
        )
    }
}

extension Connect.GetMetricDataV2Request: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.GetMetricDataV2Request {
        return .init(
            endTime: self.endTime,
            filters: self.filters,
            groupings: self.groupings,
            interval: self.interval,
            maxResults: self.maxResults,
            metrics: self.metrics,
            nextToken: token,
            resourceArn: self.resourceArn,
            startTime: self.startTime
        )
    }
}

extension Connect.ListAgentStatusRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListAgentStatusRequest {
        return .init(
            agentStatusTypes: self.agentStatusTypes,
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListApprovedOriginsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListApprovedOriginsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListAuthenticationProfilesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListAuthenticationProfilesRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListBotsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListBotsRequest {
        return .init(
            instanceId: self.instanceId,
            lexVersion: self.lexVersion,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListContactEvaluationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListContactEvaluationsRequest {
        return .init(
            contactId: self.contactId,
            instanceId: self.instanceId,
            nextToken: token
        )
    }
}

extension Connect.ListContactFlowModulesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListContactFlowModulesRequest {
        return .init(
            contactFlowModuleState: self.contactFlowModuleState,
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListContactFlowVersionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListContactFlowVersionsRequest {
        return .init(
            contactFlowId: self.contactFlowId,
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListContactFlowsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListContactFlowsRequest {
        return .init(
            contactFlowTypes: self.contactFlowTypes,
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListContactReferencesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListContactReferencesRequest {
        return .init(
            contactId: self.contactId,
            instanceId: self.instanceId,
            nextToken: token,
            referenceTypes: self.referenceTypes
        )
    }
}

extension Connect.ListDefaultVocabulariesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListDefaultVocabulariesRequest {
        return .init(
            instanceId: self.instanceId,
            languageCode: self.languageCode,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListEvaluationFormVersionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListEvaluationFormVersionsRequest {
        return .init(
            evaluationFormId: self.evaluationFormId,
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListEvaluationFormsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListEvaluationFormsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListFlowAssociationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListFlowAssociationsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            resourceType: self.resourceType
        )
    }
}

extension Connect.ListHoursOfOperationOverridesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListHoursOfOperationOverridesRequest {
        return .init(
            hoursOfOperationId: self.hoursOfOperationId,
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListHoursOfOperationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListHoursOfOperationsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListInstanceAttributesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListInstanceAttributesRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListInstanceStorageConfigsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListInstanceStorageConfigsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            resourceType: self.resourceType
        )
    }
}

extension Connect.ListInstancesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListInstancesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListIntegrationAssociationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListIntegrationAssociationsRequest {
        return .init(
            instanceId: self.instanceId,
            integrationArn: self.integrationArn,
            integrationType: self.integrationType,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListLambdaFunctionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListLambdaFunctionsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListLexBotsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListLexBotsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListPhoneNumbersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListPhoneNumbersRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            phoneNumberCountryCodes: self.phoneNumberCountryCodes,
            phoneNumberTypes: self.phoneNumberTypes
        )
    }
}

extension Connect.ListPhoneNumbersV2Request: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListPhoneNumbersV2Request {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            phoneNumberCountryCodes: self.phoneNumberCountryCodes,
            phoneNumberPrefix: self.phoneNumberPrefix,
            phoneNumberTypes: self.phoneNumberTypes,
            targetArn: self.targetArn
        )
    }
}

extension Connect.ListPredefinedAttributesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListPredefinedAttributesRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListPromptsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListPromptsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListQueueQuickConnectsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListQueueQuickConnectsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            queueId: self.queueId
        )
    }
}

extension Connect.ListQueuesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListQueuesRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            queueTypes: self.queueTypes
        )
    }
}

extension Connect.ListQuickConnectsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListQuickConnectsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            quickConnectTypes: self.quickConnectTypes
        )
    }
}

extension Connect.ListRealtimeContactAnalysisSegmentsV2Request: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListRealtimeContactAnalysisSegmentsV2Request {
        return .init(
            contactId: self.contactId,
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            outputType: self.outputType,
            segmentTypes: self.segmentTypes
        )
    }
}

extension Connect.ListRoutingProfileQueuesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListRoutingProfileQueuesRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            routingProfileId: self.routingProfileId
        )
    }
}

extension Connect.ListRoutingProfilesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListRoutingProfilesRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListRulesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListRulesRequest {
        return .init(
            eventSourceName: self.eventSourceName,
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            publishStatus: self.publishStatus
        )
    }
}

extension Connect.ListSecurityKeysRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListSecurityKeysRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListSecurityProfileApplicationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListSecurityProfileApplicationsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            securityProfileId: self.securityProfileId
        )
    }
}

extension Connect.ListSecurityProfilePermissionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListSecurityProfilePermissionsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            securityProfileId: self.securityProfileId
        )
    }
}

extension Connect.ListSecurityProfilesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListSecurityProfilesRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListTaskTemplatesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListTaskTemplatesRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            name: self.name,
            nextToken: token,
            status: self.status
        )
    }
}

extension Connect.ListTrafficDistributionGroupUsersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListTrafficDistributionGroupUsersRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            trafficDistributionGroupId: self.trafficDistributionGroupId
        )
    }
}

extension Connect.ListTrafficDistributionGroupsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListTrafficDistributionGroupsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListUseCasesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListUseCasesRequest {
        return .init(
            instanceId: self.instanceId,
            integrationAssociationId: self.integrationAssociationId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListUserHierarchyGroupsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListUserHierarchyGroupsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListUserProficienciesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListUserProficienciesRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            userId: self.userId
        )
    }
}

extension Connect.ListUsersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListUsersRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Connect.ListViewVersionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListViewVersionsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            viewId: self.viewId
        )
    }
}

extension Connect.ListViewsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.ListViewsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            type: self.type
        )
    }
}

extension Connect.SearchAgentStatusesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.SearchAgentStatusesRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            searchCriteria: self.searchCriteria,
            searchFilter: self.searchFilter
        )
    }
}

extension Connect.SearchAvailablePhoneNumbersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.SearchAvailablePhoneNumbersRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            phoneNumberCountryCode: self.phoneNumberCountryCode,
            phoneNumberPrefix: self.phoneNumberPrefix,
            phoneNumberType: self.phoneNumberType,
            targetArn: self.targetArn
        )
    }
}

extension Connect.SearchContactFlowModulesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.SearchContactFlowModulesRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            searchCriteria: self.searchCriteria,
            searchFilter: self.searchFilter
        )
    }
}

extension Connect.SearchContactFlowsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.SearchContactFlowsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            searchCriteria: self.searchCriteria,
            searchFilter: self.searchFilter
        )
    }
}

extension Connect.SearchContactsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.SearchContactsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            searchCriteria: self.searchCriteria,
            sort: self.sort,
            timeRange: self.timeRange
        )
    }
}

extension Connect.SearchHoursOfOperationOverridesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.SearchHoursOfOperationOverridesRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            searchCriteria: self.searchCriteria,
            searchFilter: self.searchFilter
        )
    }
}

extension Connect.SearchHoursOfOperationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.SearchHoursOfOperationsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            searchCriteria: self.searchCriteria,
            searchFilter: self.searchFilter
        )
    }
}

extension Connect.SearchPredefinedAttributesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.SearchPredefinedAttributesRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            searchCriteria: self.searchCriteria
        )
    }
}

extension Connect.SearchPromptsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.SearchPromptsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            searchCriteria: self.searchCriteria,
            searchFilter: self.searchFilter
        )
    }
}

extension Connect.SearchQueuesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.SearchQueuesRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            searchCriteria: self.searchCriteria,
            searchFilter: self.searchFilter
        )
    }
}

extension Connect.SearchQuickConnectsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.SearchQuickConnectsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            searchCriteria: self.searchCriteria,
            searchFilter: self.searchFilter
        )
    }
}

extension Connect.SearchResourceTagsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.SearchResourceTagsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            resourceTypes: self.resourceTypes,
            searchCriteria: self.searchCriteria
        )
    }
}

extension Connect.SearchRoutingProfilesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.SearchRoutingProfilesRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            searchCriteria: self.searchCriteria,
            searchFilter: self.searchFilter
        )
    }
}

extension Connect.SearchSecurityProfilesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.SearchSecurityProfilesRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            searchCriteria: self.searchCriteria,
            searchFilter: self.searchFilter
        )
    }
}

extension Connect.SearchUserHierarchyGroupsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.SearchUserHierarchyGroupsRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            searchCriteria: self.searchCriteria,
            searchFilter: self.searchFilter
        )
    }
}

extension Connect.SearchUsersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.SearchUsersRequest {
        return .init(
            instanceId: self.instanceId,
            maxResults: self.maxResults,
            nextToken: token,
            searchCriteria: self.searchCriteria,
            searchFilter: self.searchFilter
        )
    }
}

extension Connect.SearchVocabulariesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Connect.SearchVocabulariesRequest {
        return .init(
            instanceId: self.instanceId,
            languageCode: self.languageCode,
            maxResults: self.maxResults,
            nameStartsWith: self.nameStartsWith,
            nextToken: token,
            state: self.state
        )
    }
}
